METHOD AND SYSTEM FOR ACCELERATING AI TRAINING WITH ADVANCED INTERCONNECT TECHNOLOGIES

Abstract

According to various embodiments, methods and systems are provided to accelerate artificial intelligence (AI) model training with advanced interconnect communication technologies and systematic zero-value compression over a distributed training system. According to an exemplary method, during each iteration of a Scatter-Reduce process performed on a cluster of processors arranged in a logical ring to train a neural network model, a processor receives a compressed data block from a prior processor in the logical ring, performs an operation on the received compressed data block and a compressed data block generated on the processor to obtain a calculated data block, and sends the calculated data block to a following processor in the logical ring. A compressed data block calculated from corresponding data blocks from the processors can be identified on each processor and distributed to each other processor and decompressed therein for use in the AI model training.

Description

TECHNICAL FIELD

Embodiments of the present disclosure relate generally to machine learning. More particularly, embodiments of the disclosure relate to neural network training.

BACKGROUND

Neural networks are becoming increasingly complex in order to solve complex problems. Complex neural networks require complex deep learning algorithms and more data bandwidth during the training phase. As a result, training time, cost, and power consumption have increased. To accelerate training, advanced servers, for example, faster servers or server clusters with more sophisticated interface, have been used to improve computing and communications to reduce the cost of expensive hardware. However, existing solutions still present challenges in terms of performance and cost.

BRIEF DESCRIPTION OF THE DRAWINGS

Embodiments of the disclosure are illustrated by way of example and not limitation in the figures of the accompanying drawings in which like references indicate similar elements.

FIG. 1 illustrates an example of a system for use in AI model training in accordance with an embodiment.

FIGS. 2A-2F illustrate an example process of data transfer in AI model training in accordance with an embodiment.

FIG. 3 illustrates an example process that represents an improvement over the process in FIGS. 2A-2F.

FIG. 4 illustrates an example architecture of data compress, data operation and interconnect buses in accordance with an embodiment.

FIG. 5 illustrates a zero-sum compression technique in accordance with an embodiment.

FIG. 6 illustrates an example operation on compressed data in accordance with an embodiment.

FIG. 7 illustrates an example process of AI model training in accordance with an embodiment.

DETAILED DESCRIPTION

Various embodiments and aspects of the disclosures will be described with reference to details discussed below, and the accompanying drawings will illustrate the various embodiments. The following description and drawings are illustrative of the disclosure and are not to be construed as limiting the disclosure. Numerous specific details are described to provide a thorough understanding of various embodiments of the present disclosure. However, in certain instances, well-known or conventional details are not described in order to provide a concise discussion of embodiments of the present disclosures.

Reference in the specification to “one embodiment” or “an embodiment” means that a particular feature, structure, or characteristic described in conjunction with the embodiment can be included in at least one embodiment of the disclosure. The appearances of the phrase “in one embodiment” in various places in the specification do not necessarily all refer to the same embodiment.

According to various embodiments, methods and systems are provided herein to accelerate artificial intelligence (AI) training with advanced interconnect communication technologies. Utilizing both software and hardware components, embodiments described in the disclosure can significantly lower the interconnect communications bandwidth requirement, power consumption, and reduce the training time, thereby improving training performance without the penalty of precision loss. Systematic data compression and decompression are used over a distributed system for AI model training, coupled with the use of the highly efficient All-Reduce algorithm.

According to one embodiment, a computer-implemented method of AI model training includes the operations of performing multiple iterations in a Scatter-Reduce process on a cluster of processors, each of which can be a graphical processing unit (GPU). The processors can be arranged in a logical ring to train a neural network model, each processor including multiple data blocks, each data block representing a set of parameters or a set of gradients for updating a set of parameters in the neural network model.

During each iteration, a processor receives a compressed data block from a prior processor in the logical ring, performs an operation on the received compressed data block and a compressed data block generated on the processor to obtain a calculated data block, and sends the calculated data block to a following processor in the logical ring. By the end of the multiple iterations, each data block on the multiple processors would have been compressed and operated on. The method further includes the operation of identifying on each of the plurality of processors a compressed data block calculated from corresponding data blocks from the plurality of processors.

In one embodiment, the identified compressed data block can be distributed to each of the other processors in the logical ring, and can be decompressed on the processor for use in updating parameters in the neural network model. The processors can be attached to central processing units (CPUs) in different systems of the distributed AI model training system. In one embodiment, each processor can include a hardware-based or software-based compression module utilizing a zero-value compression technique to compress and decompress data blocks. A compressed data block can be represented by a data structure with a bitmask section and a compressed data section, and the bitmask includes bits indicating positions in the block of data that have non-zero values.

According to one embodiment, when a request for AI training is received from a central processing unit (CPU), each of the general-purpose processing units (GPUs) arranged in a logical ring is configured to perform data processing (DP) operations on the data blocks distributed from the CPU iteratively in a pipelined manner. Each GPU operates as a DP accelerator with respect to the CPU. For each iteration, during a first DP cycle, each GPU performs a first predetermined DP operation (e.g., data compression) on one of the data blocks respectively in parallel and generates a respective DP result. During a second DP cycle, each GPU transmits via a respective inter-processor link the respective DP result to a respective downstream GPU in the logical ring to be further processed therein. For the purpose of illustration, a GPU is utilized as an example of a DP accelerator, however, other types of processors or processing logic may be utilized as DP accelerators.

In one embodiment, during the second DP cycle, each GPU further receives a processing result from its respective upstream GPU in the logical ring via a respective inter-processor link for further processing at the GPU. In one embodiment, during a third DP cycle, each of the GPUs concurrently performs a second predetermined DP operation (e.g., a combine operation such as a summation) on a first data block processed by itself (e.g., a processing result) and a second data block received from its upstream GPU (e.g., a processing result by the upstream GPU). In one embodiment, during a fourth DP cycle, each of the GPUs performs a further DP operation such as a data decompression operation.

FIG. 1 illustrates an example of a system for use in AI model training in accordance with an embodiment. As shown in FIG. 1, the system includes a cluster of GPUs 101 scattered in a number of servers, for example, server A 103 and server B 105, where each server includes one or more CPUs and each CPU is associated with one or more DP accelerators such as GPUs. The servers can include CPUs 107 and 109 that communicate with each other via an Ethernet connection 111. In the example system as shown in FIG. 1, each CPU can have a number of GPUs connected to the CPU via a PCIe (peripheral component interconnect express) switch. For example, in server A 103, the GPUs 117, 119 and 121 are connected to CPU A 107 via PCIe switch A 113; in server B 105, the GPUs 123, 125 and 127 are connected to s CPU B 109 via PCIe B 115.

The CPUs 107 and 109 can communicate with each other via an inter-processor link such as the Ethernet connection 111 to coordinate the task of training a neural network. For example, job commands can be distributed to each server via the Ethernet connection 111. A job command can then be dispatched from the CPU in the server to the GPUs connected to that CPU. Once the job command is dispatched, data among the GPUs in the system can be transferred via a respective inter-processor link or connection such as a Cache Coherent Interconnect for Accelerators (CCIX) compatible connection. As shown in FIG. 1, the GPUs in the system are arranged in a bi-directional ring topology although a uni-directional ring topology can be used.

CCIX is an open cache coherent interconnect architecture developed by the CCIX Consortium. CCIX is designed to simplify the communication between the central processor (e.g., CPU) and the various accelerators (e.g., GPU) in the system through a cache-coherent extension to standard PCIe. CCIX is a high-performance, chip-to-chip interconnect architecture that provides a cache coherent framework for heterogeneous system architectures. Cache coherency is automatically maintained at all time between the central processing unit and the various other accelerators in the system. Every CCIX-support device incorporates at least a single CCIX port which is pin-compatible with any other CCIX-enabled device. CCIX supports a large set of topologies such as chip-to-chip, chip-switch-chip, mesh, daisy chains, and rings.

In one embodiment, the GPUs are configured to perform AI training operations on data blocks distributed from their respective CPUs in a pipelined manner. Each of the GPUs also communicates with each other via an inter-processor link. The GPUs may be configured in a ring arrangement to receive a processing result of an upstream GPU for further data processing. Each GPU may further send a processing result to its corresponding downstream GPU to be further processed therein. Thus, each of the GPUs performs its assigned DP operation in parallel and sends its DP result to a downstream GPU. Meanwhile, each GPU further receives a processing result from its upstream GPU for further processing therein.

FIGS. 2A-2F illustrate an example process of data transfer in AI model training in accordance with an embodiment. Although three GPUs 203, 205 and 207 are shown herein, the example process can use as many as GPUs (e.g., thousands of GPUs) depending on a number of factors, for example, the complexity of the neural network to be trained, the size of the training data and the desired training speed of the user.

Examples of neural networks that can be trained on the example system include a multilayer perceptron (MLP) neural network, which includes a collection of connected neurons. The neurons in the MLP neural network can be fully connected, with each neuron in one layer connecting with parameters (e.g., weights and biases) to every neuron in the following layer.

During the training of a neural network model, gradient descent (i.e. backpropagation) can be used to determine a set of parameters that minimize the difference between expected values and actual output of the neural network model. The gradient descent includes the steps of calculating gradients of the loss/error function, and updating existing parameters in response to the gradients. The cycle can be repeated until the minima of the loss function are reached.

In one embodiment, a training dataset for the neutral network model can be divided into multiple of subsets, with each subset used for training the neural network model on one of the GPUs, such that the training of the neural network can be conducted in parallel by the multiple GPUs. Each GPUs can have a complete copy of the neural network model.

Each subset of the training dataset can be logically divided into multiple of equal-sized chunks of data. The number of the chunks may be equal to the number of the GPUs in the example process. The parallelizing training of the neural network model need multiple iterations for the gradient descent. For each iteration, every GPU runs forward propagation of the neural network model on the data on that GPU, followed by error backpropagation to compute the gradient of the loss with respect to the network parameters. The GPUs can subsequently communicate with each other to compute a statistic of the gradients (e.g., average, a maximum or a minimum), and apply the statistic (e.g. an average gradient) to obtain updated parameters. The neural network model may have a large number of parameters (e.g., billions of parameters) and each parameter may be associated with a gradient value. As such, the size of the gradients can be huge for the neural network, and transferring the gradients between the GPUs can take a tremendous amount of bandwidth.

Referring back to FIGS. 2A-2F, the example process illustrates an algorithm for reducing bandwidth requirement for data transfer among the GPUs. In one embodiment, bandwidth as used herein is the maximum rate of data transfer across a given network connection. The algorithm can include two processes. The first process is a Scatter-Reduce process and the second process is an Allgather process. During the Scatter-Produce process, the GPUs can exchange data such that every GPU ends up with a chunk of the final result. During the Allgather process, the GPUs can exchange those chunks such that all GPUs end up with the complete final result.

Each GPU can include one or more applications configured to partition the subset of training dataset on that GPU into the equal-sized data chunks; the number of the data chunks on each GPU is the number of the GPUs in the example system. Each data chunks can generate its own set of gradients during the training of the neural network model.

In this example, as shown above, since there are three GPUs in the system, and accordingly, the number of data chunks on each GPU is three. From the subset of the training data on GPU #0203, three sets of gradients a₀ 215, b₀ 231, c₀ 237 can be generated; from the subset of the training data on GPU #1205, three sets of gradients a₁ 217, b₁ 233, c₁ 239 are also generated. Similarly, from the subset of the training data on GPU #2207, three sets of gradients a₂ 219, b₂ 235, c₂ 241 are generated. In one embodiment, the different sets of gradients on each GPU can be stored in an array or another data structure.

As an illustration, the algorithm is designed to sum up the gradients generated by each subset of the training dataset, such that upon the completion of the algorithm each GPU will have the sums of the gradients generated from the training dataset.

The GPUs in the example process can have a N −1 iterations during the Scatter-Reduce process, where N is the total number of GPUs in the system. As such, the GPUs in the example system can have 2 iterations. In each iteration, each GPU can send a set of gradients on the GPU to its right neighbor, receive a set of gradients from its left neighbor, and add up the two sets of gradients to generate a new set of gradients. The set of gradients being sent and received by every GPU is different for each iteration; the nth GPU starts by sending the nth set of gradients, and receives the (n-1)th set of gradients, and then proceeds backwards from there.

FIGS. 2A-2C illustrate the Scatter-Reduce process. FIG. 2A illustrates data transfer in the first iteration of the Scatter-Reduce process. After the first send and receive is completed, each GPU will have an array element with a value representing the sum of two sets of gradients on two different GPUs. For example, the first element a₁ on the GPU 205 can include the sum of the sets of gradients from the second GPU 205 and the first GPU 215. FIG. 2B illustrates data transfer in the second iteration of the Scatter-Reduce process, and also shows the intermediate sums after the first iteration of the Scatter-Reduce process is complete. In the second iteration, the Scatter-Reduce process continues, and by the end of the Scatter-Reduce process (namely after the second iteration in this example), each GPU will have one array element that contains the sum of all gradients in corresponding array elements across all the GPUs. FIG. 2C illustrates a final state at the end of the Scatter-Reduce process.

FIGS. 2D-2F illustrate the Allgather process, which proceeds identically to the Scatter-Reduce and also have N −1 iterations, except instead of accumulating gradients that the GPUs receive, the received gradients overwrite the gradients in a corresponding array element on the receiving GPU. FIG. 2D illustrates data transfer in the first iteration of the Allgather process. After the first iteration is completed, each GPU will have two array elements that each contains the sum of all gradients in corresponding array elements across all the GPUs, as shown in FIG. 2E. FIG. 2E shows the Allgather process in the second iteration, namely, the final iterations in the example process. By the end of the Allgather process as shown in FIG. 2F, GPU will have the fully accumulated gradients from the entire training dataset. Since all the data transfers occur synchronously in discrete iterations, the example process is bandwidth-optimal.

FIG. 3 illustrates an example process that represents an improvement over the process in FIGS. 2A-2F. In one embodiment, the example process shown in FIG. 3 can be used for transferring gradients for updating neural network parameters during the training of the neural network model, where tens of megabytes of data may need to be transferred in between distributed servers and operated collaboratively. This requires highly efficient hardware and software to improve the performance and latency.

In one embodiment, the example process leverages the All-Reduce algorithm and software and hardware co-design to improve both performance and latency. The software and hardware co-design refers to the simultaneous design of both hardware and software to achieve a desire function. The example process uses hardware components such as Cache Coherent Interconnect for Accelerators (CCIX) for connecting GPUs in a cluster, and software modules such as zero-value compression modules and other compression modules for enabling hardware computing based on compressed data. The example process uses systematic data compression over a distributed system designed to execute a highly efficient All-Reduce process. Therefore, gradients generated from different subsets of a training dataset can be accumulated and distributed to each GPU faster, thus accelerating AI model training.

In FIG. 3, the left part of 4 shows a typical All-Reduce process 302, which has been detailed in FIGS. 2A-2F; while the right part describes an improved All-Reduce process with systematic compression over a distributed system. FIG. 3 uses three GPUs as an example, and the three GPUs are arranged to create a logical ring.

In both the typical All-Reduce Process 302 and the improved All-Reduce Process, data blocks to be transferred among the CPUs are stored in a data structure (e.g., an array), and the data blocks can be gradients generated from different chunks of a subset of a training dataset for training a neural network model. Each GPU can have a complete copy of the neural network model to be trained. The gradients are transferred among the GPUs for updating parameters of the neural network model.

In one embodiment, during the first iteration or first processing cycle of the Scatter-Reduce process, data blocks on each GPU can be compressed by a compression module, which can be implemented on hardware or as a software module. For example, data block a₀ on GPU #0203, data block b₁ on GPU #1205, and, data block c₂ in GPU #2207 are all compressed respectively in operations 301, 315 and 329.

The compressed data blocks can be sent to the neighbor GPUs in a next processing cycle. For example, the compressed data block on GPU #0203 can be sent to GPU #1205 in operation 303, the compressed data block on GPU #1205 can be sent to GPU #2207 in operation 317, and the compressed data block on GPU #2207 can be sent to GPU #0203 in operation 331.

In one embodiment, at the same time that the compressed data blocks are sent to the neighbor GPUs, a different block of data on each GPU can be compressed and added to a compressed data received as described above. In this example embodiment, the operation of addition is used as an example; other operations (e.g., multiplication, deduction, and mathematical averaging) can also be used.

For example, in operation 305, the data block c₀ on GPU #0203 can be compressed, and added to the compressed data block c₂, which has been received from GPU #2205. In operation 319, the data block a₁ on GPU #1205 can be compressed and added to the compressed data block a₀, which has been received from GPU #0. In operation 333, the data block b₂ on GPU #2 can be compressed can added to the compressed data block b₁, which has been received from GPU #0203.

The above process can be repeated for each remaining iteration of the Scatter-Reduce process. The number of iterations can be the number of GPUs minus 1. As such, the Scatter-Reduce process in the improved All-Reduce process 305 can have 2 iterations. In each of the remaining iterations, each GPU, instead of sending the original compressed data block on the GPU, can send the sum of compressed data blocks from multiple GPUs to the next GPU.

For example, during the second iteration, GPU #0203 can send the sum of the compressed data block c₀ and the compressed data block c₂ to GPU #1205 in operation 309. GPU #1205 can send the sum of the compressed data block a₀ and the compressed data block a₁ to GPU #2207 in operation 32. GPU #2207 can send the sum of the compressed data block b₁ and the compressed data block b₂ to GPU #0203 in operation 335.

In one embodiment, at the same time that the sums of the compressed data blocks are sent to the neighbor GPUs, each GPU can compress the remaining data block on the GPU and added the compressed data block to the sum of compressed data blocks previously received from a prior GPU in the logic ring. For example, in operation 309, the data block b₀ on GPU #0202 can be compressed and added to the sum of the compressed data blocks b₁ and b₂. In operation 323, the data block c₁ on GPU #1205 can be compressed and added to the sum of the compressed data blocks c₀ and c₂. In operation 337, the data block a₂ on GPU #2207 can be compressed and added to the sum of the compressed data blocks a₀ and a₁.

Therefore, at the end of the Scatter-Reduce process, each GPU will have a sum of compressed data blocks from corresponding positions in the arrays across all the GPUs in the example process.

During the Allgather process, each GPU can distribute the sum of the compressed data blocks from the corresponding positions in the array to each other GPU such that by the end of the Allgather process, each GPU will have a copy of the sum of all compressed data blocks. Each GPU can then decompress the compressed sum as shown in operations 313, 327 and 341. The decompressed sum on each GPU can be used to update the parameters of the copy of the neural network model on that GPU.

FIG. 4 illustrates an example architecture of data compress, data operation and interconnect buses in accordance with an embodiment.

The diagram in FIG. 3 illustrates a data flow of compressing raw data blocks 405 and 407, and transferring the compressed data blocks over interconnect buses 416 and 418, operate 413 and 419 over compressed data and de-compress the compressed data to raw data.

As shown in FIG. 3, a pair of compression module and decompression module can be used on each GPU. For example, on GPU A 401, a compression module 412 and a decompression module 409 are used, and on GPU B 403, a compression module 417 and a decompression module 415 are used.

For the compression modules 412 and 417, any compression algorithm can be used. An example compression algorithm is a zero-value compression algorithm/technique, which is described in detailed below in the disclosure. Given a zero-value ratio of 50%, the bandwidth saving for data transfer can be close to 50% using the zero-value compression algorithm; when combined with various operations on the compressed data and interconnect buses, the bandwidth benefit can be more than 50%.

FIG. 5 illustrates a zero-sum compression technique in accordance with an embodiment. In FIG. 5, a matrix 513 is an original 4×4 data array used for the training of a neural network model. A data structure 510 shows a compressed form of the matrix 513 using the zero-value compression technique. The data structure 510 includes a number of fields, for example, a type field 501, a length field 503, a bitmask field 505 and a compressed data field 507. The matrix 513 and the data structure 510 can be converted into each other using compression 511 and decompression 509.

In one embodiment, the type field 501 indicates the data type of values in the matrix 415. Examples of data types can include floating points (FP) 32, FP 16, and Integer (INT) 8. The length indicates the total size of the bitmask field 505 and the compressed data field 507 in bytes; or the size of the compressed data field 507 with the fixed size of bitmask byes. The bitmask field 505 field indicates a non-zero value in a particular position in the matrix 513 with ‘1” set, and a zero-value with ‘0’ set. The compressed data 507 field includes only non-zero value data with the right alignment/offset. The bitmask field can also be used by a decompression module (e.g., the decompression module 409 or 415 in FIG. 4) to write the non-zero values in back to their original positions in the 4×4 data array 513.

FIG. 6 illustrates an example operation on compressed data in accordance with an embodiment. As shown in FIG. 6, a summation operation is provided as an example to illustrate how an operation is conducted on two compressed data blocks.

In one embodiment, compressed data 617 is a data structure representing matrix A 613 in its compressed form, and compressed data 619 is a data structure representing matrix B 615 in its compressed form. Both structures are generated using the compression technique described in FIG. 5, and can be respectively decompressed to matrix A 613 and matrix B 615 using a decompression module (e.g., the decompression module 409 or 415).

In one embodiment, to sum the two compressed matrixes 613 and 615 in their compressed forms, a hardware compression module (e.g., compression module 411 or 417 in FIG. 4) can first pipeline the two compressed data structures 617 and 619, compare the bits in the bitmask field in one data structure against the bits in the bitmask field of another data structure, and output a result 621 based on the comparison.

With the data transferred between GPUs in compressed form, bandwidth requirement for data transfer can be reduced. Further, compressed data blocks take less memory than their uncompressed forms, memory requirement for operations on the compressed data blocks may also be reduced, since less bits are read from memory and written to memory during the operations.

For example, a summation operation may require two reads and one write. Since the data read from memory and written to memory are in compressed form, memory requirement for the summation operation is reduced.

FIG. 7 illustrates an example process 700 of AI model training in accordance with an embodiment. Process 700 may be performed by processing logic which may include software, hardware, or a combination thereof.

Referring back to FIG. 7, in operation 701, a plurality of iterations are performed on a plurality of processors that are arranged in a logical ring to train a neural network model, with each processor including a plurality of data blocks. In operation 702, for each of the plurality of iterations, a processor in the plurality of processors receives a compressed data block from a prior processor in the logical ring, performs an operation on the received compressed data block and a compressed data block generated on the processor to obtain a calculated data block, and sends the calculated data block to a following processor in the logical ring. In operation 703, a compressed data block that is calculated from corresponding data blocks from the plurality of processors is identified on each of the plurality of processors. The identified data block is distributed to each other processor and decompressed therein for use in the AI model training, for example, updating parameters of a neural network model.

Note that some or all of the components as shown and described above may be implemented in software, hardware, or a combination thereof. For example, such components can be implemented as software installed and stored in a persistent storage device, which can be loaded and executed in a memory by a processor (not shown) to carry out the processes or operations described throughout this application. Alternatively, such components can be implemented as executable code programmed or embedded into dedicated hardware such as an integrated circuit (e.g., an application specific IC or ASIC), a digital signal processor (DSP), or a field programmable gate array (FPGA), which can be accessed via a corresponding driver and/or operating system from an application. Furthermore, such components can be implemented as specific hardware logic in a processor or processor core as part of an instruction set accessible by a software component via one or more specific instructions.

Some portions of the preceding detailed descriptions have been presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the ways used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. An algorithm is here, and generally, conceived to be a self-consistent sequence of operations leading to a desired result. The operations are those requiring physical manipulations of physical quantities.

All of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the above discussion, it is appreciated that throughout the description, discussions utilizing terms such as those set forth in the claims below, refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system memories or registers or other such information storage, transmission or display devices.

Embodiments of the disclosure also relate to an apparatus for performing the operations herein. Such a computer program is stored in a non-transitory computer readable medium. A machine-readable medium includes any mechanism for storing information in a form readable by a machine (e.g., a computer). For example, a machine-readable (e.g., computer-readable) medium includes a machine (e.g., a computer) readable storage medium (e.g., read only memory (“ROM”), random access memory (“RAM”), magnetic disk storage media, optical storage media, flash memory devices).

The processes or methods depicted in the preceding figures may be performed by processing logic that comprises hardware (e.g. circuitry, dedicated logic, etc.), software (e.g., embodied on a non-transitory computer readable medium), or a combination of both. Although the processes or methods are described above in terms of some sequential operations, it should be appreciated that some of the operations described may be performed in a different order. Moreover, some operations may be performed in parallel rather than sequentially.

Embodiments of the present disclosure are not described with reference to any particular programming language. It will be appreciated that a variety of programming languages may be used to implement the teachings of embodiments of the disclosure as described herein.

In the foregoing specification, embodiments of the disclosure have been described with reference to specific exemplary embodiments thereof. It will be evident that various modifications may be made thereto without departing from the broader spirit and scope of the disclosure as set forth in the following claims. The specification and drawings are, accordingly, to be regarded in an illustrative sense rather than a restrictive sense.

Claims

1. A computer-implemented method of artificial intelligence (AI) model training using data processing (DP) accelerators, the method comprising: receiving a request from a central processing unit (CPU) for training an AI model based on a set of training data having a plurality of data blocks distributed from the CPU; andperforming a plurality of DP iterations by a plurality of general-purpose processing units (GPUs) that are arranged in a logical ring to train the AI model, including for each of the DP iterations, during a first DP cycle, each of the GPUs performing a first predetermined DP operation on one of the data blocks respectively in parallel, generating a respective DP result, andduring a second DP cycle, each of the GPUs transmitting a first respective DP result to a downstream GPU in the logical ring via an inter-processor link to be further processed therein.

2. The method of claim 1, further comprising, during the second DP cycle, receiving by each of the GPUs a second respective DP result from an upstream GPU in the logical ring via a respective inter-processor link for further processing.

3. The method of claim 2, further comprising, during a third DP cycle, performing, by each of the GPUs concurrently, a second predetermined DP operation on a data block processed and received from a respective upstream GPU.

4. The method of claim 3, wherein the second predetermined DP operation is performed on a first data block processed by a current GPU and a second data block processed by a respective upstream GPU, generating a first DP result.

5. The method of claim 4, wherein the second predetermined DP operation comprises a combine operation of the first data block and the second data block.

6. The method of claim 4, further comprising, during a fourth DP cycle, performing, by each of the GPUs concurrently, a third predetermined DP operation on the first DP result.

7. The method of claim 6, wherein the third predetermined DP operation comprises a data decompression operation.

8. The method of claim 1, wherein the inter-processor link comprises a Cache Coherent Interconnect for Accelerators (CCIX) connection.

9. The method of claim 1, wherein at least a portion of the data blocks represents parameters or gradients generated as a part of the AI model training.

10. The method of claim 1, wherein the first processing DP operation comprises a data compression operation.

11. The method of claim 10, wherein the data compression operation is performed using a zero-value compression algorithm, which compresses one or more data blocks into a data structure having a bitmask section and a compressed data section, wherein the bitmask includes bits indicating positions in the data blocks having non-zero values.

12. A data processing system, comprising: at least one central processing unit (CPU); anda plurality of general-purpose processing units (GPUs) coupled to the CPU, wherein each of the GPUs is configured to perform artificial intelligence (AI) data processing (DP) operations distributed from the CPU, the operations including receiving a request from a central processing unit (CPU) for training an AI model based on a set of training data having a plurality of data blocks distributed from the CPU, andperforming a plurality of DP iterations by a plurality of general-purpose processing units (GPUs) that are arranged in a logical ring to train the AI model, including for each of the DP iterations, during a first DP cycle, each of the GPUs performing a first predetermined DP operation on one of the data blocks respectively in parallel, generating a respective DP result, andduring a second DP cycle, each of the GPUs transmitting a first respective DP result to a downstream GPU in the logical ring via an inter-processor link to be further processed therein.

13. The system of claim 12, wherein the operations further comprise, during the second DP cycle, receiving by each of the GPUs a second respective DP result from an upstream GPU in the logical ring via a respective inter-processor link for further processing.

14. The system of claim 13, wherein the operations further comprise, during a third DP cycle, performing, by each of the GPUs concurrently, a second predetermined DP operation on a data block processed and received from a respective upstream GPU.

15. The system of claim 14, wherein the second predetermined DP operation is performed on a first data block processed by a current GPU and a second data block processed by a respective upstream GPU, generating a first DP result.

16. The system of claim 15, wherein the second predetermined DP operation comprises a combine operation of the first data block and the second data block.

17. The system of claim 15, wherein the operations further comprise, during a fourth DP cycle, performing, by each of the GPUs concurrently, a third predetermined DP operation on the first DP result.

18. The system of claim 17, wherein the third predetermined DP operation comprises a data decompression operation.

19. A non-transitory machine-readable medium having instructions stored therein, which when executed by a processor, cause the processor to perform operations artificial intelligence (AI) training, the operations comprising: receiving a request from a central processing unit (CPU) for training an AI model based on a set of training data having a plurality of data blocks distributed from the CPU; andperforming a plurality of DP iterations by a plurality of general-purpose processing units (GPUs) that are arranged in a logical ring to train the AI model, including for each of the DP iterations, during a first DP cycle, each of the GPUs performing a first predetermined DP operation on one of the data blocks respectively in parallel, generating a respective DP result, andduring a second DP cycle, each of the GPUs transmitting a first respective DP result to a downstream GPU in the logical ring via an inter-processor link to be further processed therein.

20. The machine-readable medium of claim 19, wherein the operations further comprise, during the second DP cycle, receiving by each of the GPUs a second respective DP result from an upstream GPU in the logical ring via a respective inter-processor link for further processing.