Wanderer001
Wanderer001

torch.distributed

参考 torch.distributed.init_process_group() - 云+社区 - 腾讯云

目录

后端

PyTorch自带的后端

使用哪个后端？

常见的环境变量

基础

初始化

torch.distributed.is_available()[source]

torch.distributed.init_process_group(backend, init_method=None, timeout=datetime.timedelta(0, 1800), world_size=-1, rank=-1, store=None, group_name='')[source]

class torch.distributed.Backend

torch.distributed.get_backend(group=)[source]

torch.distributed.get_rank(group=)[source]

torch.distributed.get_world_size(group=)[source]

torch.distributed.is_initialized()[source]

torch.distributed.is_mpi_available()[source]

torch.distributed.is_nccl_available()[source]

TCP初始化

共享文件系统初始化

环境变量初始化

组

torch.distributed.new_group(ranks=None, timeout=datetime.timedelta(0, 1800), backend=None)[source]

点对点通信

torch.distributed.send(tensor, dst, group=, tag=0)[source]

torch.distributed.recv(tensor, src=None, group=, tag=0)[source]

torch.distributed.isend(tensor, dst, group=, tag=0)[source]

torch.distributed.irecv(tensor, src, group=, tag=0)[source]

同步和异步收集操作

收集函数

torch.distributed.broadcast(tensor, src, group=, async_op=False)[source]

torch.distributed.all_reduce(tensor, op=ReduceOp.SUM, group=, async_op=False)[source]

torch.distributed.reduce(tensor, dst, op=ReduceOp.SUM, group=, async_op=False)[source]

torch.distributed.all_gather(tensor_list, tensor, group=, async_op=False)[source]

torch.distributed.gather(tensor, gather_list=None, dst=0, group=, async_op=False)[source]

torch.distributed.scatter(tensor, scatter_list=None, src=0, group=, async_op=False)[source]

torch.distributed.reduce_scatter(output, input_list, op=ReduceOp.SUM, group=, async_op=False)[source]

torch.distributed.all_to_all(output_tensor_list, input_tensor_list, group=, async_op=False)[source]

torch.distributed.barrier(group=, async_op=False)[source]

class torch.distributed.ReduceOp

class torch.distributed.reduce_op[source]

多GPU收集函数

torch.distributed.broadcast_multigpu(tensor_list, src, group=, async_op=False, src_tensor=0)[source]

torch.distributed.all_reduce_multigpu(tensor_list, op=ReduceOp.SUM, group=, async_op=False)[source]

torch.distributed.reduce_multigpu(tensor_list, dst, op=ReduceOp.SUM, group=, async_op=False, dst_tensor=0)[source]

torch.distributed.all_gather_multigpu(output_tensor_lists, input_tensor_list, group=, async_op=False)[source]

torch.distributed.reduce_scatter_multigpu(output_tensor_list, input_tensor_lists, op=ReduceOp.SUM, group=, async_op=False)[source]

后端

torch.distributed支持三种后端，每个都有不同的能力，下表展示了那个函数对使用CPU/CUDA张量是可以得到的。MPI只有在构建PyTorch的实现支持CUDA时才支持它。

torch.distributed_第1张图片

PyTorch自带的后端

Pytorch分布式现在仅仅支持Linux。默认地，用Gloo和NCLL后端用来构建，并且包含在Pytorch分布式中(NCCL仅仅使用CUDA时才构筑)。MPI是一个可选的后端，并且仅仅在如果你从Pytorch源中构建时才包含。(例如，在一个MPI已经安装的Host上构建Pytorch。)

使用哪个后端？

过去，我们经常问：“我应该使用哪个后端？”

经验法则

GPU的分布式训练使用NCCL后端

CPU分布式训练使用Gloo后端

GPU host使用无限制宽带互连：

  • 使用NCCL，因为它是目前唯一支持无限制宽带和GPUDirect的后端。

GPU hosts使用以太网互连：

  • 使用NCCL，因为它目前提供最佳分布式GPU训练性能，特别对于多进程单点或者多点分布式训练。如果你遇到任何NCCL的问题，使用Gloo作为应急计划选项。(注意对于GPU目前Gloo比NCCL运行的慢)

CPU hosts用无限制带宽连接：

  • 如果无限制带宽支持IB上的IP，使用Gloo，否则，使用MPI作为替代，我们计划在即将更新的版本中加入Gloo的无限制带宽支持。
  • CPU hosts with Ethernet interconnect

用以太网连接的GPU：

  • Use Gloo, unless you have specific reasons to use MPI.
  • 使用Gloo，除非你有特殊的原因需要使用MPI。

常见的环境变量

选择要使用的网络接口

默认的，NCCL和Gloo后端都会尝试尽力选择正确的网络接口来使用。如果自动检测到的接口不正确，你可以使用下面的环境变量来重写：

  • NCCL_SOCKET_IFNAME, for example export NCCL_SOCKET_IFNAME=eth0
  • GLOO_SOCKET_IFNAME, for example export GLOO_SOCKET_IFNAME=eth0

如果你使用Gloo后端，你可以通过用逗号分隔它们来指定一个多借口而，比如export GLOO_SOCKET_IFNAME=eth0,eth1,eth2,eth3。后端将会在这些接口上以循环的方式派遣操作。在这些变量中所有进程指定相同的接口号很重要。

Other NCCL environment variables

其他NCCL环境变量。

NCCL提供了大量的环境变量来微调这个目的。

通常使用下面用来debugging目的中的一个：

  • export NCCL_DEBUG=INFO
  • export NCCL_DEBUG_SUBSYS=ALL

对NCCL环境变量的全部列表，请参考NVIDIA NCCL’s official documentation

基础

torch.distributed包提供Pytorch支持和通信基元，对多进程并行，在一个或多个机器上运行的若干个计算阶段。类torch.nn.parallel.DistributedDataParallel() 基于此功能来提供同步式分布式训练，作为任何Pytorch模块的包裹器。这和Multiprocessing package - torch.multiprocessing 和torch.nn.DataParallel()提供的并行式不同，它支持多网络连接的机器，对每个进程使用者必须明确的启动一个主训练脚本的一个分开的副本。

在单个机器同步的情况下，torch.distributed或者torch.nn.parallel.DistributedDataParallel()包裹器，相对于其他数据并行的方法包括torch.nn.DataParallel()依然有很大的优势：

  • 在每次迭代时每个进程保持自己的优化器并且执行一个完全的优化步骤。同时这也许会出现冗余，因为梯度已经聚合在一起，并且平均到进程上，因此对每个进程都是一样的，这意味着不需要无参数广播步骤，减少了张量和节点之间的时间花费。
  • 每个进程进程包含一个独立的Pytorch解释器，消除额外的解释器超出。来自执行若干执行线程的GIL-thrashing，模型复制或来自单个Python进程的GPUs。这对模型特别重要使得Python的运行时间能够大量使用，包括使用循环成的模型或者许多小的组件。

初始化

在调用任何方法之前，这个包需要使用torch.distributed.init_process_group()来进行初始化。这将阻塞，直到所有进程都已加入。

torch.distributed.is_available()[source]

如果分布式包可以获得的话就返回True。否则，torch.distributed对任何API都是不可见的。目前，torch.distributed在Linux和MacOS上都可以得到。设置USE_DISTRIBUTED=1来启动它，当从源中构建PyTorch时。目前，对Linux系统，默认值是USE_DISTRIBUTED=1，对MacOS系统，默认值是USE_DISTRIBUTED=0。

torch.distributed.init_process_group(backend, init_method=None, timeout=datetime.timedelta(0, 1800), world_size=-1, rank=-1, store=None, group_name='')[source]

初始化默认的分布式进程组，并且也会初始化分布式包。

There are 2 main ways to initialize a process group:

有两种主要的方式来进行初始化过程：

  1. 明确的指定store，rank和world_size
  2. 指定init_method (一个URL字符串)，这指明在哪里和如何发现同类。选择性的指定rank和world_size，或者编码所有在URL中需要的参数，并且忽略它们。

如果两者都没有指定，init_method假定为"env://"。

参数：

  • backend(str或Backend)：--要使用的backend。依赖于构筑时间配置，mpi, gloo, nccl作为有效值。这个参数以小写字符串表示(例如，“gloo”)，这也能通过Backend属性(例如，Backend.GLOO)来访问。如果利用nccl在每个机器上使用多进程，每个进程必须独占访问它使用的每个GPU，因为在进程间共享GPU将会导致停滞。
  • init_method(str，可选)--URL指定如何初始化进程组。默认是“env://”，如果init_method和store都没有指定的时候。和store是互斥的。
  • world_size (python:int, optional) – Number of processes participating in the job. Required if store is specified.
  • world_size(int，可选的)--在工作中参与的进程数，如果store指定时需要设置。
  • rank (python:int, optional) – Rank of the current process. Required if store is specified.
  • rank(int, 可选的)--当前进程的等级。如果store指定时就需要设置。
  • store(store，可选的)--所有工作可访问的键/值存储，用于交换连接/地址信息。与init_method互斥。
  • timeout(timedelta,可选的)--对流程组执行的操作的超时。默认值为30分钟。这适用于gloo后端。对于nccl，只有在环境变量NCCL_BLOCKING_WAIT被设置为1时才适用。

  • group_name(str，可选的，丢弃)--组名字。

为了使得backend == Backend.MPI，PyTorch需要在支持MPI的系统上从源代码构建。这对NCCL同样适用。

class torch.distributed.Backend

一个可获得后端的类似枚举的类：GLOO，NCLL和MPI。

这个类的值是小写字母，例如"gloo"。它们可以作为属性来访问，例如Backend,NCCL。

这个类能直接调用来解析字符串，例如Backend(backend_str)，如果back_ste是空时将会检查。如果是这样的话，返回解析后的小写字母字符串。它也接受大写字符串，例如Backend("GLOO")，返回"gloo"。

注意

入口端。UNDEFINED存在，但仅用作某些字段的初始值。用户不应该直接使用它，也不应该假设它的存在。

torch.distributed.get_backend(group=)[source]

返回给定进程组的后端。

参数：

  • group (ProcessGroup, optional) – 要处理的过程组。默认是通用的主进程组。如果其他指定的组指定后，调用的过程必须是group的 一部分。

返回值：

  • 给定进程组的后端，作为一个小写字母的字符串。

torch.distributed.get_rank(group=)[source]

返回当前进程组的等级。在一个分布式进程组内，rank是一个独特的识别器分配到每个进程。它们通常是从0到world_size的连续的整数。

参数：

  • group (ProcessGroup, optional) – 要处理的过程组。

返回值：

  • 如果不是组的一部分，等级就是进程组-1。

torch.distributed.get_world_size(group=)[source]

返回当前进程组的进程数。

参数：

  • group (ProcessGroup, optional) – 要处理的过程组。

返回值：

  • 如果不是组的一部分，进程组的world_size就为-1。

torch.distributed.is_initialized()[source]

  • 检查默认的进程数是否已经被初始化

torch.distributed.is_mpi_available()[source]

  • 检查MPI后端是否可以得到

torch.distributed.is_nccl_available()[source]

  • 检查NCCL后端是否可以得到。

目前支持三种初始化方式：

TCP初始化

使用TCP时有两种初始化方法，两者都需要一个所有进程都可以访问的网络地址和一个想要的world_size。第一种方法需要指定一个属于rank 0集成的地址。这个初始化方法需要对所有进程手动指定等级。注意多路广播地址在最近的分布式包中已经不再支持。group_name也已经丢弃了。

import torch.distributed as dist

# Use address of one of the machines
dist.init_process_group(backend, init_method='tcp://10.1.1.20:23456',
                        rank=args.rank, world_size=4)

共享文件系统初始化

其他初始化方法使用一个文件系统，这个文件系统是共享的，并且在一个组内所有的机器都是能看见的，伴随着需要的world_size。URL应该以file://开始，并且包含共享文件系统中不存在文件的路径(在一个存在的目录中)。如果它不存在的话，文件系统初始化会自动创建一个文件，但是将会杉树文件。因此，你必须确定这个文件是否已在下一次init_process_group()调用相同文件路径名之前已经删除。注意多路广播地址在最近的分布式包中已经不再支持。group_name也已经丢弃了。

警告

这个方法假定文件系统支持用fant1锁定 - 大多数局部系统和NFS支持它。

警告

这个方法通常创建一个文件并且尽力去删除还在程序结束时移除这个文件。换句话说，用文件初始化方法初始的每个初始化将会需要一个需要一个全新的空文件，以便初始化成功。如果通过以前初始化后的文件再一次使用(没有清楚干净时将会发生)，这是不希望发生的行为，并且进程会导致僵局和失败。因此，如果自动删除没有发生的话，尽管这个方法将会尽力清除这个文件，你必须保证文件在训练结束时被移除，来阻止相同的文件在下一次中再次使用。如果你计划在同样的文件系统中调用init_process_group()时，这非常重要。换句话说，如果文件没有移除和清楚，并且你再一次在那个文件上调用init_process_group()，将会发生失败。这里的经验法则是，确保在调用文件 init_process_group()不存在或者是空的。

import torch.distributed as dist

# rank should always be specified
dist.init_process_group(backend, init_method='file:///mnt/nfs/sharedfile',
                        world_size=4, rank=args.rank)

环境变量初始化

这个方法将会从环境变量中读取配置，允许人们完全定做信息如何获得。变量设置为：

  • MASTER_PORT - 需要，在rank 0的机器上必须是一个空闲接口

  • MASTER_ADDR - 需要(除了rank 0)；rank 0节点的地址

  • WORLD_SIZE - 需要；可以在这里设置或者在初始化函数中调

  • RANK - 需要；可以在这里设置或者在初始化函数中调用

级别为0的机器将用于设置所有连接。这是默认方法，意味着不需要指定init_method(也可以是env://)。

组

在默认组上收集默认操作(也称为world)并且需要要求所有进程进入分布式函数调用。然而，一些工作量也从更多细粒度通信中受益。这就是分布式组发挥作用的地方。new_group()函数可以用来闯进新的组，利用所有进程的任意子集。它返回一个不透明的组句柄，可以将其作为组参数提供给所有集合(集合是用于在某些众所周知的编程模式中交换信息的分布式函数)。

torch.distributed.new_group(ranks=None, timeout=datetime.timedelta(0, 1800), backend=None)[source]

创建一个分布式组。这个函数需要所有在主要组的进程(例如，所有为分布式工作部分的进程)进入这个函数。额外的，在所有进程上组应该以相同的顺序创建。

参数：

  • ranks(list[python:int]) - 组员的进程列表。

  • timeout(timedelta,optinal) - 对流程组执行的操作的超时。默认值为30分钟。这只适用于gloo后端。

  • backend (str or Backend, optional) –

  • The backend to use. Depending on build-time configurations, valid values are gloo and nccl. By default uses the same backend as the global group. This field should be given as a lowercase string (e.g., "gloo"), which can also be accessed via Backend attributes (e.g., Backend.GLOO).

  • 使用的backend。依赖于构建时间配置，有效值是gloo和nccl。默认使用相同的后端作为全局组。这个域应该是小写字母的字符串(例如，“gloo”)，这也可以通过backend属性来进行访问。

返回值：

  • 分布式组的句柄，可用于集体调用。

点对点通信

torch.distributed.send(tensor, dst, group=, tag=0)[source]

以同步方式传送一个张量。

参数：

  • tensor (Tensor) – Tensor to send.

  • tensor (Tensor) – 要传送的张量。

  • dst (python:int) – Destination rank.

  • dst (python:int) – 要到达的等级。

  • group (ProcessGroup, optional) – 要处理的过程组

  • tag (python:int, optional) – 标签匹配发送与远程recv

torch.distributed.recv(tensor, src=None, group=, tag=0)[source]

同步接收一个张量。

参数：

  • tensor (Tensor) – Tensor to send.

  • tensor (Tensor) – 要传送的张量。

  • dst (python:int) – Destination rank.

  • dst (python:int) – 要到达的等级。

  • group (ProcessGroup, optional) – 要处理的过程组

  • tag (python:int, optional) – 标签匹配发送与远程recv

返回值：

  • 如果发件人不属于组，则其级别为-1。

isend() and irecv() return distributed request objects when used. In general, the type of this object is unspecified as they should never be created manually, but they are guaranteed to support two methods:

  • is_completed() - returns True if the operation has finished

  • wait() - will block the process until the operation is finished. is_completed() is guaranteed to return True once it returns.

torch.distributed.isend(tensor, dst, group=, tag=0)[source]

同步发送一个张量。

参数：

  • tensor (Tensor) – Tensor to send.

  • tensor (Tensor) – 要传送的张量。

  • dst (python:int) – Destination rank.

  • dst (python:int) – 要到达的等级。

  • group (ProcessGroup, optional) – 要处理的过程组

  • tag (python:int, optional) – 标签匹配发送与远程recv

返回值：

  • 分布式请求对象。没有，如果不是组的一部分

torch.distributed.irecv(tensor, src, group=, tag=0)[source]

同步接收一个张量。

参数：

  • tensor (Tensor) – Tensor to send.

  • tensor (Tensor) – 要传送的张量。

  • dst (python:int) – Destination rank.

  • dst (python:int) – 要到达的等级。

  • group (ProcessGroup, optional) – 要处理的过程组

  • tag (python:int, optional) – 标签匹配发送与远程recv

返回值：

  • 分布式请求对象。没有，如果不是组的一部分

同步和异步收集操作

Every collective operation function supports the following two kinds of operations:

每个收集操作都支持下面的两种收集方式：

同步操作 - 默认模式，当async_op被设置为False时。当函数返回时，它保证收集操作已经执行(如果他是一个CUDA操作的话，没有必要必须完成，因为所有的CUDA操作都是异步的)，根据集合操作的数据，可以调用任何进一步的函数调用。在同步模式下，集合函数不返回任何内容。

异步操作 - 当async_op设置为True时。收集操作函数返回一个分布式请求对象。通常情况下，你不需要手动创建它，而它保证支持两种方法：

  • is_completed() - 如果操作完成的话，返回真

  • wait() - 将会阻塞这个进程，知道操作完成。

收集函数

torch.distributed.broadcast(tensor, src, group=, async_op=False)[source]

将张量广播到整个组。在收集中所有参与的进程，张量必须有相同的元素数。

参数：

  • tensor (Tensor) – Data to be sent if src is the rank of current process, and tensor to be used to save received data otherwise.

  • tensor (Tensor) – 如果src是当前进程的号，就发送数据，并且张量保存接受数据。

  • src (python:int) – 源等级。

  • group (ProcessGroup, optional) – 要处理的过程组

  • async_op (bool, optional) – 这个op是否应该是一个异步op

Returns：

返回值：

  • 如果async_op是真的话，就返回异步工作句柄。如果async_op为空或者组的部分为空，就为空。

torch.distributed.all_reduce(tensor, op=ReduceOp.SUM, group=, async_op=False)[source]

在所有机器上减少张量数据，通过获得最终的结果。在调用之后张量在所有过程中都是按位相同的。

参数：

  • tensor (Tensor) – 输入和输出的集合。该函数在适当的位置运行。

  • op (optional) – torch.distributed.ReduceOp枚举的价值之一。指定一个操作用来进行逐元素降低。

  • group (ProcessGroup, optional) – 要处理的过程组

  • async_op (bool, optional) – 这个op时候应该是一个异步操作

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

torch.distributed.reduce(tensor, dst, op=ReduceOp.SUM, group=, async_op=False)[source]

在所有机器上减少张量数据。仅仅具有dst的等级接收最终的数据。

参数：

  • tensor (Tensor) – 输入和输出的集合。该函数在适当的位置运行。

  • op (optional) – torch.distributed.ReduceOp枚举的价值之一。指定一个操作用来进行逐元素降低。

  • group (ProcessGroup, optional) – 要处理的过程组

  • async_op (bool, optional) – 这个op时候应该是一个异步操作

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

torch.distributed.all_gather(tensor_list, tensor, group=, async_op=False)[source]

Gathers tensors from the whole group in a list.

用类表的方式再真个组中收集张量。

参数：

  • tensor_list (list[Tensor]) – Output list. It should contain correctly-sized tensors to be used for output of the collective.

  • tensor_list (list[Tensor]) – 输出的列表。它应该包含当前尺寸的张量用来进行收集的输出。

  • tensor (Tensor) – 从当前进程广播的张量。

  • group (ProcessGroup, optional) – 要处理的过程组

  • async_op (bool, optional) – 这个op时候是async_op

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

torch.distributed.gather(tensor, gather_list=None, dst=0, group=, async_op=False)[source]

以单一的进程收集张量的列表。

参数：

  • tensor (Tensor) – 输入张量。

  • gather_list (list[Tensor], optional) – 用于收集数据的适当大小的张量列表(默认为None，必须在目标级别上指定)

  • dst (python:int, optional) – 目的等级，默认是0

  • group (ProcessGroup, optional) – 要处理的过程组

  • async_op (bool, optional) – 这个op是否应该是一个异步op

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

torch.distributed.scatter(tensor, scatter_list=None, src=0, group=, async_op=False)[source]

将张量列表分散到一组中的所有进程。每个进程将只接收到一个张量，并将其数据存储在张量参数中。

参数：

  • tensor (Tensor) – 输入张量。

  • gather_list (list[Tensor], optional) – 用于收集数据的适当大小的张量列表(默认为None，必须在目标级别上指定)

  • dst (python:int, optional) – 目的等级，默认是0

  • group (ProcessGroup, optional) – 要处理的过程组

  • async_op (bool, optional) – 这个op是否应该是一个异步op

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

torch.distributed.reduce_scatter(output, input_list, op=ReduceOp.SUM, group=, async_op=False)[source]

缩减，然后分散一列张量到一组中的所有进程。

Parameters

  • output (Tensor) – 输出张量

  • input_list (list[Tensor]) –要减少和打散的张量列表

  • group (ProcessGroup, optional) – 要处理的过程租

  • async_op (bool, optional) – 这个op是否应该是一个异步op

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

torch.distributed.all_to_all(output_tensor_list, input_tensor_list, group=, async_op=False)[source]

每个进程将输入张量列表分散到一组中所有进程，并在输出列表中返回收集到的张量列表。

参数：

  • output_tensor_list (list[Tensor]) – 每个rank收集一个张量的列表

  • input_tensor_list (list[Tensor]) – 每个rank打散一个张量列表

  • group (ProcessGroup, optional) – 要处理的过程租

  • async_op (bool, optional) – 这个op是否应该是一个异步op

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

Warning

all_to_all是实验性的，可能会发生变化。

例

>>> input = torch.arange(4) + rank * 4
>>> input = list(input.chunk(4))
>>> input
[tensor([0]), tensor([1]), tensor([2]), tensor([3])]     # Rank 0
[tensor([4]), tensor([5]), tensor([6]), tensor([7])]     # Rank 1
[tensor([8]), tensor([9]), tensor([10]), tensor([11])]   # Rank 2
[tensor([12]), tensor([13]), tensor([14]), tensor([15])] # Rank 3
>>> output = list(torch.empty([4], dtype=torch.int64).chunk(4))
>>> dist.all_to_all(output, input)
>>> output
[tensor([0]), tensor([4]), tensor([8]), tensor([12])]    # Rank 0
[tensor([1]), tensor([5]), tensor([9]), tensor([13])]    # Rank 1
[tensor([2]), tensor([6]), tensor([10]), tensor([14])]   # Rank 2
[tensor([3]), tensor([7]), tensor([11]), tensor([15])]   # Rank 3

>>> # Essentially, it is similar to following operation:
>>> scatter_list = input
>>> gather_list  = output
>>> for i in range(world_size):
>>>   dist.scatter(gather_list[i], scatter_list if i == rank else [], src = i)

>>> input
tensor([0, 1, 2, 3, 4, 5])                                       # Rank 0
tensor([10, 11, 12, 13, 14, 15, 16, 17, 18])                     # Rank 1
tensor([20, 21, 22, 23, 24])                                     # Rank 2
tensor([30, 31, 32, 33, 34, 35, 36])                             # Rank 3
>>> input_splits
[2, 2, 1, 1]                                                     # Rank 0
[3, 2, 2, 2]                                                     # Rank 1
[2, 1, 1, 1]                                                     # Rank 2
[2, 2, 2, 1]                                                     # Rank 3
>>> output_splits
[2, 3, 2, 2]                                                     # Rank 0
[2, 2, 1, 2]                                                     # Rank 1
[1, 2, 1, 2]                                                     # Rank 2
[1, 2, 1, 1]                                                     # Rank 3
>>> input = list(input.split(input_splits))
>>> input
[tensor([0, 1]), tensor([2, 3]), tensor([4]), tensor([5])]                   # Rank 0
[tensor([10, 11, 12]), tensor([13, 14]), tensor([15, 16]), tensor([17, 18])] # Rank 1
[tensor([20, 21]), tensor([22]), tensor([23]), tensor([24])]                 # Rank 2
[tensor([30, 31]), tensor([32, 33]), tensor([34, 35]), tensor([36])]         # Rank 3
>>> output = ...
>>> dist.all_to_all(output, input)
>>> output
[tensor([0, 1]), tensor([10, 11, 12]), tensor([20, 21]), tensor([30, 31])]   # Rank 0
[tensor([2, 3]), tensor([13, 14]), tensor([22]), tensor([32, 33])]           # Rank 1
[tensor([4]), tensor([15, 16]), tensor([23]), tensor([34, 35])]              # Rank 2
[tensor([5]), tensor([17, 18]), tensor([24]), tensor([36])]                  # Rank 3

torch.distributed.barrier(group=, async_op=False)[source]

对所有进程进行同步。这个收集阻塞知道整个组进入这个函数，如果async_op为Fasle或者，如果在wait()上调用异步工作句柄。

参数：

  • group (ProcessGroup, optional) – 要处理的过程组

  • async_op (bool, optional) – 这个op是否应该是一个异步op

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

class torch.distributed.ReduceOp

一个枚举类型的类用来获得可以减少的操作：SUM, PRODUCT, MIN, MAX, BAND, BOR, and BXOR。这个类的值能通过属性访问，例如ReduceOp.SUM.，它们被用来指定减少集体的战略，例如 reduce(), all_reduce_multigpu()。

成员：

  • SUM
  • PRODUCT
  • MIN
  • MAX
  • BAND
  • BOR
  • BXOR

class torch.distributed.reduce_op[source]

Deprecated enum-like class for reduction operations: SUM, PRODUCT, MIN, and MAX.

ReduceOp is recommended to use instead.

多GPU收集函数

如果在每个节点上超过一个GPU，当使用NCCL或者Gloo后端时，broadcast_multigpu() all_reduce_multigpu() reduce_multigpu() 和all_gather_multigpu()在每个节点内所有多GPU都支持分布式收集操作。在过去张量列表中的每个张量需要在hosts的分开的GPU设备上，在这里调用函数。注意张量列表的长度需要在所有分布式进程上都相同。同时我们注意到目前的多GPU收集函数仅仅支持NCCL后端。例如，如果用来进行分布式训练的系统有两个节点，每个有8个GPU。在这16个GPU的每个上面，这个张量我们都需要减少。接下来的代码可以作为一个参考：

在节点0上运行代码

import torch
import torch.distributed as dist

dist.init_process_group(backend="nccl",
                        init_method="file:///distributed_test",
                        world_size=2,
                        rank=0)
tensor_list = []
for dev_idx in range(torch.cuda.device_count()):
    tensor_list.append(torch.FloatTensor([1]).cuda(dev_idx))

dist.all_reduce_multigpu(tensor_list)

在节点1上运行代码

import torch
import torch.distributed as dist

dist.init_process_group(backend="nccl",
                        init_method="file:///distributed_test",
                        world_size=2,
                        rank=1)
tensor_list = []
for dev_idx in range(torch.cuda.device_count()):
    tensor_list.append(torch.FloatTensor([1]).cuda(dev_idx))

dist.all_reduce_multigpu(tensor_list)

调用完成后，两个节点上的所有16张量的全部减少值为16。

torch.distributed.broadcast_multigpu(tensor_list, src, group=, async_op=False, src_tensor=0)[source]

将张量广播给每节点有多个GPU张量的整个组。张量在所有gpu中必须有相同数量的元素，这些元素来自于参与集合的所有进程。列表中的每个张量必须在不同的GPUOnly nccl和gloo后端是当前支持的张量，只能是GPU张量。

参数：

  • tensor_list (List[Tensor]) – 在收集操作中参与的张量。如果src是rank，指定tensor_list(tensor_list[src_tensor])的src_tensor元素将会广播到其他张量(在不同的GPU上)，在src进程和所有其他non-src进程的tensor_list。您还需要确保len(tensor_list)对于调用该函数的所有分布式进程是相同的。

  • src (python:int) – 源层级。

  • group (ProcessGroup, optional) – 要处理的过程组

  • async_op (bool, optional) – 这个op是否应该是一个异步op

  • src_tensor (python:int, optional) – 源张量在tensor_list中的秩

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

torch.distributed.all_reduce_multigpu(tensor_list, op=ReduceOp.SUM, group=, async_op=False)[source]

在所有机器上减少张量数据，以得到最终结果的方式。这个函数在每个节点处减少大量的张量，同时每个张量存在于不同的GPUs上。因此，张量列表中的输出张量需要是GPU张量。同时，张量列表中的灭个张量需要在不同的GPU上存在。调用以后，张量列表中的所有张量将会逐比特相同。仅仅nccl和gloo后端目前支持张量应该成为GPU张量。

参数：

  • 收集到的输入和输出张量的列表。函数在原地操作，并且需要在不同的GPU上每个张量是一个GPU张量。你也需要确保len(tensor_list)对所有调用这个函数的分布式训练是相同的。

  • op (optional) – torch.distributed.ReduceOp枚举来的张量之一。指定一个操作用来进行逐元素的减少。

  • group (ProcessGroup, optional) – 要处理的过程组

  • async_op (bool, optional) – 这个op是否应该是一个异步op

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

torch.distributed.reduce_multigpu(tensor_list, dst, op=ReduceOp.SUM, group=, async_op=False, dst_tensor=0)[source]

在所有机器上减少多GPU的张量数据。每个在tensor_list中的张量应该在单独的GPU中存在。只有dst为秩的进程的tensor_list[dst_张量]的GPU会接收最终结果。目前只支持nccl后端张量，只能是GPU张量。

参数：

  • tensor_list (List[Tensor]) – Input and output GPU tensors of the collective. The function operates in-place. You also need to make sure that len(tensor_list) is the same for all the distributed processes calling this function.

  • tensor_list (List[Tensor]) – 收集的输入和输出GPU张量。函数操作在原地完成。你也需要确保len(tensor_list)对所有调用这个函数的分布式进程都是相同的。

  • dst (python:int) – Destination rank

  • dst (python:int) – 目的等级

  • op (optional) – One of the values from torch.distributed.ReduceOp enum. Specifies an operation used for element-wise reductions.

  • op (optional) – 从torch.distributed.ReduceOp枚举来的值之一。指定一个用来逐元素减少的操作。

  • group (ProcessGroup, optional) – 要处理的过程组

  • async_op (bool, optional) – 这个op是否应该是一个异步op

  • dst_tensor (python:int, optional) – 目的张量在张量表中的rank

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

torch.distributed.all_gather_multigpu(output_tensor_lists, input_tensor_list, group=, async_op=False)[source]

从列表中的整个组中收集张量。每个张量在tensor_list应该驻留在一个单独的GPUOnly nccl后端，当前支持的张量应该是GPU张量。

参数：

  • output_tensor_lists (List[List[Tensor]]) –  输出列表，在每个GPU上应该包含当前尺寸的张量，用来进行收集的输出，例如output_tensor_lists[i]包含了input_tensor_list[i]的GPU上的all_gather结果。注意output_tensor_lists 的每个元素的尺寸都为world_size * len(input_tensor_list)，因为该函数在组中都收集来自每个单GPU的结果。为了解释output_tensor_lists[i]的灭个元素，注意rank k的input_tensor_list[j]将会出现在output_tensor_lists[i][k * world_size + j]。也注意到len(output_tensor_lists)，output_tensor_lists 中的每个元素的尺寸(每个元素是一个列表，因此len(output_tensor_lists[i]))需要在调用这个函数的所有进程上相等)

  • input_tensor_list (List[Tensor]) – 从当前进程广播的张量列表(在不同的gpu上)。注意，调用该函数的所有分布式进程的len(input_tensor_list)需要相同。

  • async_op (bool, optional) – 这个op是否应该是一个异步op

  • dst_tensor (python:int, optional) – 目的张量在张量表中的rank

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

torch.distributed.reduce_scatter_multigpu(output_tensor_list, input_tensor_lists, op=ReduceOp.SUM, group=, async_op=False)[source]

将一个张量列表压缩并分散到整个组中。目前只支持nccl后端。output_tensor_list中的每个张量都应该驻留在一个单独的GPU上，就像input_tensor_lists中的每个张量列表一样。

Parameters

  • output_tensor_list (List[Tensor]) – 输出张量(在不同的gpu上)来接收操作的结果。注意，调用该函数的所有分布式进程的len(output_tensor_list)需要相同。

  • input_tensor_lists (List[List[Tensor]]) – 输入列表。它应该在每个GPU上包含大小正确的张量来用于集合的输入，例如input_tensor_lists[i]包含了位于output_tensor_list[i] GPU上的reduce_scatter输入。注意，input_tensor_lists的每个元素的大小为world_size * len(output_tensor_list)，因为该函数分散了组中每个单独GPU的结果。要解释input_tensor_lists[i]的每个元素，请注意，排名k的output_tensor_list[j]接收到来自input_tensor_lists[i][k * world_size + j]的reduce-scattered结果。还要注意，len(input_tensor_lists)和input_tensor_lists中每个元素的大小(每个元素都是一个列表，因此len(input_tensor_lists[i])对于调用该函数的所有分布式进程都需要相同。

  • g

  • async_op (bool, optional) – 这个op是否应该是一个异步op

  • dst_tensor (python:int, optional) – 目的张量在张量表中的rank

返回值：

  • 如果async_op设置为真的话，是一个异步工作句柄。如果async_op为空或者部分组为空，就为None 。

 

你可能感兴趣的:(Pytorch,计算机视觉,深度学习,机器学习)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 将cmd中命令输出保存为txt文本文件 落难Coder Windowscmdwindow
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
  • 数字里的世界17期：2021年全球10大顶级数据中心，中国移动榜首 张三叨
    你知道吗？2016年，全球的数据中心共计用电4160亿千瓦时，比整个英国的发电量还多40％！前言每天，我们都会创造超过250万TB的数据。并且随着物联网（IOT）的不断普及，这一数据将持续增长。如此庞大的数据被存储在被称为“数据中心”的专用设施中。虽然最早的数据中心建于20世纪40年代，但直到1997-2000年的互联网泡沫期间才逐渐成为主流。当前人类的技术，比如人工智能和机器学习，已经将我们推向
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • 遥感影像的切片处理 sand&wich 计算机视觉python图像处理
    在遥感影像分析中，经常需要将大尺寸的影像切分成小片段，以便于进行详细的分析和处理。这种方法特别适用于机器学习和图像处理任务，如对象检测、图像分类等。以下是如何使用Python和OpenCV库来实现这一过程，同时确保每个影像片段保留正确的地理信息。准备环境首先，确保安装了必要的Python库，包括numpy、opencv-python和xml.etree.ElementTree。这些库将用于图像处理
  • 推荐3家毕业AI论文可五分钟一键生成！文末附免费教程！ 小猪包333 写论文人工智能AI写作深度学习计算机视觉
    在当前的学术研究和写作领域，AI论文生成器已经成为许多研究人员和学生的重要工具。这些工具不仅能够帮助用户快速生成高质量的论文内容，还能进行内容优化、查重和排版等操作。以下是三款值得推荐的AI论文生成器：千笔-AIPassPaper、懒人论文以及AIPaperPass。千笔-AIPassPaper千笔-AIPassPaper是一款基于深度学习和自然语言处理技术的AI写作助手，旨在帮助用户快速生成高质
  • AI大模型的架构演进与最新发展 季风泯灭的季节 AI大模型应用技术二人工智能架构
    随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
  • ai绘画工具midjourney怎么下载？附作品管理教程 设计师早上好
    Midjourney是一款功能强大的AI绘画工具，它使用机器学习技术和深度神经网络等算法，可以生成各种艺术风格的绘画作品。在创意设计、广告宣传等方面有着广泛的应用前景。那么，ai绘画工具midjourney怎么下载？本文将为您介绍Midjourney的下载以及作品的相关管理。一、Midjourney下载Midjourney的下载非常简单，只需打开Midjourney官网（点击“GetMidjour
  • [实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估pytorchpython机器学习
    文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
  • [实践应用] 深度学习之优化器 YuanDaima2048 深度学习工具使用pytorch深度学习人工智能机器学习python优化器
    文章总览：YuanDaiMa2048博客文章总览深度学习之优化器1.随机梯度下降（SGD）2.动量优化（Momentum）3.自适应梯度（Adagrad）4.自适应矩估计（Adam）5.RMSprop总结其他介绍在深度学习中，优化器用于更新模型的参数，以最小化损失函数。常见的优化函数有很多种，下面是几种主流的优化器及其特点、原理和PyTorch实现：1.随机梯度下降（SGD）原理:随机梯度下降通过
  • 机器学习-聚类算法 不良人龍木木 机器学习机器学习算法聚类
    机器学习-聚类算法1.AHC2.K-means3.SC4.MCL仅个人笔记，感谢点赞关注！1.AHC2.K-means3.SC传统谱聚类：个人对谱聚类算法的理解以及改进4.MCL目前仅专注于NLP的技术学习和分享感谢大家的关注与支持！
  • 生成式地图制图 Bwywb_3 深度学习机器学习深度学习生成对抗网络
    生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
  • 未来软件市场是怎么样的？做开发的生存空间如何？ cesske 软件需求
    目录前言一、未来软件市场的发展趋势二、软件开发人员的生存空间前言未来软件市场是怎么样的？做开发的生存空间如何？一、未来软件市场的发展趋势技术趋势：人工智能与机器学习：随着技术的不断成熟，人工智能将在更多领域得到应用，如智能客服、自动驾驶、智能制造等，这将极大地推动软件市场的增长。云计算与大数据：云计算服务将继续普及，大数据技术的应用也将更加广泛。企业将更加依赖云计算和大数据来优化运营、提升效率，并
  • 吴恩达深度学习笔记(30)-正则化的解释 极客Array
    正则化（Regularization）深度学习可能存在过拟合问题——高方差，有两个解决方法，一个是正则化，另一个是准备更多的数据，这是非常可靠的方法，但你可能无法时时刻刻准备足够多的训练数据或者获取更多数据的成本很高，但正则化通常有助于避免过拟合或减少你的网络误差。如果你怀疑神经网络过度拟合了数据，即存在高方差问题，那么最先想到的方法可能是正则化，另一个解决高方差的方法就是准备更多数据，这也是非常
  • 个人学习笔记7-6：动手学深度学习pytorch版-李沐 浪子L 深度学习深度学习笔记计算机视觉python人工智能神经网络pytorch
    #人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
  • python中zeros用法_Python中的numpy.zeros()用法 江平舟 python中zeros用法
    numpy.zeros()函数是最重要的函数之一,广泛用于机器学习程序中。此函数用于生成包含零的数组。numpy.zeros()函数提供给定形状和类型的新数组,并用零填充。句法numpy.zeros(shape,dtype=float,order='C'参数形状：整数或整数元组此参数用于定义数组的尺寸。此参数用于我们要在其中创建数组的形状,例如(3,2)或2。dtype：数据类型(可选)此参数用于
  • 深度学习-点击率预估-研究论文2024-09-14速读 sp_fyf_2024 深度学习人工智能
    深度学习-点击率预估-研究论文2024-09-14速读1.DeepTargetSessionInterestNetworkforClick-ThroughRatePredictionHZhong,JMa,XDuan,SGu,JYao-2024InternationalJointConferenceonNeuralNetworks,2024深度目标会话兴趣网络用于点击率预测摘要：这篇文章提出了一种新
  • 计算机视觉中，Pooling的作用 Wils0nEdwards 计算机视觉人工智能
    在计算机视觉中，Pooling（池化）是一种常见的操作，主要用于卷积神经网络（CNN）中。它通过对特征图进行下采样，减少数据的空间维度，同时保留重要的特征信息。Pooling的作用可以归纳为以下几个方面：1.降低计算复杂度与内存需求Pooling操作通过对特征图进行下采样，减少了特征图的空间分辨率（例如，高度和宽度）。这意味着网络需要处理的数据量会减少，从而降低了计算量和内存需求。这对大型神经网络
  • 【NumPy】深入解析numpy.zeros()函数 二七830 numpy
    欢迎莅临我的个人主页这里是我深耕Python编程、机器学习和自然语言处理（NLP）领域，并乐于分享知识与经验的小天地！博主简介：我是二七830，一名对技术充满热情的探索者。多年的Python编程和机器学习实践，使我深入理解了这些技术的核心原理，并能够在实际项目中灵活应用。尤其是在NLP领域，我积累了丰富的经验，能够处理各种复杂的自然语言任务。技术专长：我熟练掌握Python编程语言，并深入研究了机
  • OpenCV图像处理技术（Python）——入门 森屿_ opencv
    ©FuXianjun.AllRightsReserved.OpenCV入门图像作为人类感知世界的视觉基础，是人类获取信息、表达信息的重要手段，OpenCV作为一个开源的计算机视觉库，它包括几百个易用的图像成像和视觉函数，既可以用于学术研究，也可用于工业邻域，它于1999年由因特尔的GaryBradski启动，OpenCV库主要由C和C++语言编写，它可以在多个操作系统上运行。1.1图像处理基本操作
  • 【中国国际航空-注册_登录安全分析报告】 风控牛 验证码接口安全评测系列安全行为验证极验网易易盾智能手机
    前言由于网站注册入口容易被黑客攻击，存在如下安全问题：1.暴力破解密码，造成用户信息泄露2.短信盗刷的安全问题，影响业务及导致用户投诉3.带来经济损失，尤其是后付费客户，风险巨大，造成亏损无底洞所以大部分网站及App都采取图形验证码或滑动验证码等交互解决方案，但在机器学习能力提高的当下，连百度这样的大厂都遭受攻击导致点名批评，图形验证及交互验证方式的安全性到底如何？请看具体分析一、中国国际航空PC
  • 机器学习 流形数据降维：UMAP 降维算法 小嗷犬 Python机器学习#数据分析及可视化机器学习算法人工智能
    ✅作者简介：人工智能专业本科在读，喜欢计算机与编程，写博客记录自己的学习历程。个人主页：小嗷犬的个人主页个人网站：小嗷犬的技术小站个人信条：为天地立心，为生民立命，为往圣继绝学，为万世开太平。本文目录UMAP简介理论基础特点与优势应用场景在Python中使用UMAP安装umap-learn库使用UMAP可视化手写数字数据集UMAP简介UMAP（UniformManifoldApproximatio
  • 损失函数与反向传播 Star_. PyTorchpytorch深度学习python
    损失函数定义与作用损失函数(lossfunction)在深度学习领域是用来计算搭建模型预测的输出值和真实值之间的误差。1.损失函数越小越好2.计算实际输出与目标之间的差距3.为更新输出提供依据（反向传播)常见的损失函数回归常见的损失函数有：均方差（MeanSquaredError，MSE）、平均绝对误差（MeanAbsoluteErrorLoss，MAE）、HuberLoss是一种将MSE与MAE
  • 七.正则化 愿风去了
    吴恩达机器学习之正则化（Regularization）http://www.cnblogs.com/jianxinzhou/p/4083921.html从数学公式上理解L1和L2https://blog.csdn.net/b876144622/article/details/81276818虽然在线性回归中加入基函数会使模型更加灵活，但是很容易引起数据的过拟合。例如将数据投影到30维的基函数上，模
  • 机器学习-------数据标准化 罔闻_spider 数据分析算法机器学习人工智能
    什么是归一化，它与标准化的区别是什么？一作用在做训练时，需要先将特征值与标签标准化，可以防止梯度防炸和过拟合；将标签标准化后，网络预测出的数据是符合标准正态分布的—StandarScaler()，与真实值有很大差别。因为StandarScaler()对数据的处理是（真实值-平均值）/标准差。同时在做预测时需要将输出数据逆标准化提升模型精度：标准化/归一化使不同维度的特征在数值上更具比较性，提高分类
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • 【安装环境】配置MMTracking环境 xuanyu22 安装环境机器学习神经网络深度学习python
    版本v0.14.0安装torchnumpy的版本不能太高，否则后面安装时会发生冲突。先安装numpy，因为pytorch的安装会自动配置高版本numpy。condainstallnumpy=1.21.5mmtracking支持的torch版本有限，需要找到合适的condainstallpytorch==1.11.0torchvision==0.12.0cudatoolkit=10.2-cpytor
  • Python(PyTorch)和MATLAB及Rust和C++结构相似度指数测量导图 亚图跨际 Python交叉知识算法量化检查图像压缩质量低分辨率多光谱峰值信噪比端到端优化图像压缩手术机器人三维实景实时可微分渲染重建三维可视化
    要点量化检查图像压缩质量低分辨率多光谱和高分辨率图像实现超分辨率分析图像质量图像索引/多尺度结构相似度指数和光谱角映射器及视觉信息保真度多种指标峰值信噪比和结构相似度指数测量结构相似性图像分类PNG和JPEG图像相似性近似算法图像压缩，视频压缩、端到端优化图像压缩、神经图像压缩、GPU变速图像压缩手术机器人深度估计算法重建三维可视化推理图像超分辨率算法模型三维实景实时可微分渲染算法MATLAB结构
  • HttpClient 4.3与4.3版本以下版本比较 spjich javahttpclient
    网上利用java发送http请求的代码很多，一搜一大把，有的利用的是java.net.*下的HttpURLConnection，有的用httpclient，而且发送的代码也分门别类。今天我们主要来说的是利用httpclient发送请求。 httpclient又可分为 httpclient3.x httpclient4.x到httpclient4.3以下 httpclient4.3
  • Essential Studio Enterprise Edition 2015 v1新功能体验 Axiba .net
    概述：Essential Studio已全线升级至2015 v1版本了！新版本为JavaScript和ASP.NET MVC添加了新的文件资源管理器控件，还有其他一些控件功能升级，精彩不容错过，让我们一起来看看吧！ syncfusion公司是世界领先的Windows开发组件提供商，该公司正式对外发布Essential Studio Enterprise Edition 2015 v1版本。新版本
  • [宇宙与天文]微波背景辐射值与地球温度 comsci 背景
            宇宙这个庞大,无边无际的空间是否存在某种确定的,变化的温度呢?      如果宇宙微波背景辐射值是表示宇宙空间温度的参数之一,那么测量这些数值,并观测周围的恒星能量输出值,我们是否获得地球的长期气候变化的情况呢?   &nbs
  • lvs-server 男人50 server
    #!/bin/bash # # LVS script for VS/DR # #./etc/rc.d/init.d/functions # VIP=10.10.6.252 RIP1=10.10.6.101 RIP2=10.10.6.13 PORT=80 case $1 in start)   /sbin/ifconfig eth2:0 $VIP broadca
  • java的WebCollector爬虫框架 oloz 爬虫
    WebCollector主页： https://github.com/CrawlScript/WebCollector 下载：webcollector-版本号-bin.zip将解压后文件夹中的所有jar包添加到工程既可。 接下来看demo package org.spider.myspider; import cn.edu.hfut.dmic.webcollector.cra
  • jQuery append 与 after 的区别 小猪猪08
    1、after函数 定义和用法： after() 方法在被选元素后插入指定的内容。 语法： $(selector).after(content) 实例： <html> <head> <script type="text/javascript" src="/jquery/jquery.js"></scr
  • mysql知识充电 香水浓 mysql
    索引 索引是在存储引擎中实现的，因此每种存储引擎的索引都不一定完全相同，并且每种存储引擎也不一定支持所有索引类型。 根据存储引擎定义每个表的最大索引数和最大索引长度。所有存储引擎支持每个表至少16个索引，总索引长度至少为256字节。 大多数存储引擎有更高的限制。MYSQL中索引的存储类型有两种：BTREE和HASH，具体和表的存储引擎相关； MYISAM和InnoDB存储引擎
  • 我的架构经验系列文章索引 agevs 架构
    下面是一些个人架构上的总结，本来想只在公司内部进行共享的，因此内容写的口语化一点，也没什么图示，所有内容没有查任何资料是脑子里面的东西吐出来的因此可能会不准确不全，希望抛砖引玉，大家互相讨论。 要注意，我这些文章是一个总体的架构经验不针对具体的语言和平台，因此也不一定是适用所有的语言和平台的。 （内容是前几天写的，现附上索引）   前端架构 http://www.
  • Android so lib库远程http下载和动态注册 aijuans andorid
    一、背景      在开发Android应用程序的实现，有时候需要引入第三方so lib库，但第三方so库比较大，例如开源第三方播放组件ffmpeg库, 如果直接打包的apk包里面, 整个应用程序会大很多.经过查阅资料和实验，发现通过远程下载so文件，然后再动态注册so文件时可行的。主要需要解决下载so文件存放位置以及文件读写权限问题。   二、主要
  • linux中svn配置出错 conf/svnserve.conf:12: Option expected 解决方法 baalwolf option
    在客户端访问subversion版本库时出现这个错误： svnserve.conf:12: Option expected 为什么会出现这个错误呢，就是因为subversion读取配置文件svnserve.conf时，无法识别有前置空格的配置文件，如### This file controls the configuration of the svnserve daemon, if you##
  • MongoDB的连接池和连接管理 BigCat2013 mongodb
    在关系型数据库中，我们总是需要关闭使用的数据库连接，不然大量的创建连接会导致资源的浪费甚至于数据库宕机。这篇文章主要想解释一下mongoDB的连接池以及连接管理机制，如果正对此有疑惑的朋友可以看一下。 通常我们习惯于new 一个connection并且通常在finally语句中调用connection的close()方法将其关闭。正巧，mongoDB中当我们new一个Mongo的时候，会发现它也
  • AngularJS使用Socket.IO bijian1013 JavaScriptAngularJSSocket.IO
            目前，web应用普遍被要求是实时web应用，即服务端的数据更新之后，应用能立即更新。以前使用的技术（例如polling）存在一些局限性，而且有时我们需要在客户端打开一个socket，然后进行通信。         Socket.IO(http://socket.io/)是一个非常优秀的库，它可以帮你实
  • [Maven学习笔记四]Maven依赖特性 bit1129 maven
    三个模块 为了说明问题，以用户登陆小web应用为例。通常一个web应用分为三个模块，模型和数据持久化层user-core, 业务逻辑层user-service以及web展现层user-web， user-service依赖于user-core user-web依赖于user-core和user-service   依赖作用范围  Maven的dependency定义
  • 【Akka一】Akka入门 bit1129 akka
    什么是Akka Message-Driven Runtime is the Foundation to Reactive Applications In Akka, your business logic is driven through message-based communication patterns that are independent of physical locatio
  • zabbix_api之perl语言写法 ronin47 zabbix_api之perl
    zabbix_api网上比较多的写法是python或curl。上次我用java－－http://bossr.iteye.com/blog/2195679，这次用perl。for example: #!/usr/bin/perl use 5.010 ; use strict ; use warnings ; use JSON :: RPC :: Client ; use
  • 比优衣库跟牛掰的视频流出了，兄弟连Linux运维工程师课堂实录，更加刺激，更加实在！ brotherlamp linux运维工程师linux运维工程师教程linux运维工程师视频linux运维工程师资料linux运维工程师自学
    比优衣库跟牛掰的视频流出了，兄弟连Linux运维工程师课堂实录，更加刺激，更加实在！   ----------------------------------------------------- 兄弟连Linux运维工程师课堂实录-计算机基础-1-课程体系介绍1 链接：http://pan.baidu.com/s/1i3GQtGL 密码：bl65   兄弟连Lin
  • bitmap求哈密顿距离-给定N（1<=N<=100000）个五维的点A(x1,x2,x3,x4,x5)，求两个点X(x1,x2,x3,x4,x5)和Y( bylijinnan java
    import java.util.Random; /** * 题目： * 给定N（1<=N<=100000）个五维的点A(x1,x2,x3,x4,x5)，求两个点X(x1,x2,x3,x4,x5)和Y(y1,y2,y3,y4,y5)， * 使得他们的哈密顿距离（d=|x1-y1| + |x2-y2| + |x3-y3| + |x4-y4| + |x5-y5|）最大
  • map的三种遍历方法 chicony map
    package com.test; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class TestMap { public static v
  • Linux安装mysql的一些坑 chenchao051 linux
    1、mysql不建议在root用户下运行   2、出现服务启动不了，111错误，注意要用chown来赋予权限， 我在root用户下装的mysql，我就把usr/share/mysql/mysql.server复制到/etc/init.d/mysqld, (同时把my-huge.cnf复制/etc/my.cnf)  chown -R cc /etc/init.d/mysql
  • Sublime Text 3 配置 daizj 配置Sublime Text
    Sublime Text 3 配置解释(默认){// 设置主题文件“color_scheme”: “Packages/Color Scheme – Default/Monokai.tmTheme”,// 设置字体和大小“font_face”: “Consolas”,“font_size”: 12,// 字体选项：no_bold不显示粗体字，no_italic不显示斜体字，no_antialias和
  • MySQL server has gone away 问题的解决方法 dcj3sjt126com SQL Server
    MySQL server has gone away 问题解决方法，需要的朋友可以参考下。 应用程序（比如PHP）长时间的执行批量的MYSQL语句。执行一个SQL，但SQL语句过大或者语句中含有BLOB或者longblob字段。比如，图片数据的处理。都容易引起MySQL server has gone away。 今天遇到类似的情景，MySQL只是冷冷的说：MySQL server h
  • javascript/dom:固定居中效果 dcj3sjt126com JavaScript
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&
  • 使用 Spring 2.5 注释驱动的 IoC 功能 e200702084 springbean配置管理IOCOffice
    使用 Spring 2.5 注释驱动的 IoC 功能 developerWorks 文档选项 将打印机的版面设置成横向打印模式 打印本页 将此页作为电子邮件发送 将此页作为电子邮件发送 级别： 初级 陈 雄华 ([email protected]), 技术总监, 宝宝淘网络科技有限公司 2008 年 2 月 28 日  &nb
  • MongoDB常用操作命令 geeksun mongodb
    1.   基本操作 db.AddUser(username,password)               添加用户 db.auth(usrename,password)      设置数据库连接验证 db.cloneDataBase(fromhost)    
  • php写守护进程（Daemon） hongtoushizi PHP
    转载自： http://blog.csdn.net/tengzhaorong/article/details/9764655   守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进程。php也可以实现守护进程的功能。   1、基本概念   &nbs
  • spring整合mybatis,关于注入Dao对象出错问题 jonsvien DAOspringbeanmybatisprototype
    今天在公司测试功能时发现一问题： 先进行代码说明： 1，controller配置了Scope="prototype"（表明每一次请求都是原子型）    @resource/@autowired service对象都可以（两种注解都可以）。 2，service 配置了Scope="prototype"（表明每一次请求都是原子型）
  • 对象关系行为模式之标识映射 home198979 PHP架构企业应用对象关系标识映射
    HELLO!架构   一、概念 identity Map:通过在映射中保存每个已经加载的对象，确保每个对象只加载一次，当要访问对象的时候，通过映射来查找它们。其实在数据源架构模式之数据映射器代码中有提及到标识映射，Mapper类的getFromMap方法就是实现标识映射的实现。     二、为什么要使用标识映射？ 在数据源架构模式之数据映射器中 //c
  • Linux下hosts文件详解 pda158 linux
    　1、主机名： 　　无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。 　　公网：IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。 　　局域网：每台机器都有一个主机名，用于主机与主机之间的便于区分，就可以为每台机器设置主机
  • nginx配置文件粗解 spjich javanginx
    #运行用户#user  nobody;#启动进程,通常设置成和cpu的数量相等worker_processes  2;#全局错误日志及PID文件#error_log  logs/error.log;#error_log  logs/error.log  notice;#error_log  logs/error.log  inf
  • 数学函数 w54653520 java
    public  class  S {        // 传入两个整数，进行比较，返回两个数中的最大值的方法。      public  int  get( int  num1, int  nu