Patent Grant
11029963
Applied Machine Learning (ML) is a booming field that utilizes a cascade of layers of nonlinear processing units and algorithms for feature extraction and transformation with a wide variety of usages and applications. Machine learning typically involves two phases, training, which uses a rich set of training data to train a plurality of machine learning models, and inference, which applies the trained machine learning models to actual applications. Each of the two phases poses a distinct set of requirements for its underlying infrastructures. Various infrastructures may be used, e.g., graphics processing unit (GPU), a central processing unit (CPU), a Field Programmable Gate Array (FPGA), an Application Specific Integrated Circuit (ASIC), etc.
Specifically, the training phase focuses on, as a non-limiting example, GPU or ASIC infrastructures that scale with the trained models and retraining frequency, wherein the key objective of the training phase is to achieve high performance and reduce training time. The inference phase, on the other hand, focuses on infrastructures that scale with the applications, user, and data, and the key objective of the inference phase is to achieve energy (e.g., performance per watt) and capital (e.g., return on investment) efficiency.
ML is usually very computationally and data intensive. Unfortunately, as the input data and model sizes grow, data movement becomes a bottleneck and data processing increases because in order to perform simple processing, three operations or instructions are performed for each data, e.g., load, processing, and store. As the amount of data grows, performing these three operations or instructions becomes burdensome. Moreover, the current computing architecture is not scalable and are not well suited for ML and its applications, since a lot of time goes in loading and storing the data in comparison to processing the data. For non-limiting examples, although a CPU is flexible and may be used for ML, it has low performance efficiencies in ML applications because of it performs loads and stores in a manner that is flexible and applicable to all forms of software. This flexibility causes it to perform extra work in hardware, which reduces its efficiency. Although a graphics Pipeline Unit (GPU) may have a higher performance than a CPU, it is burdened with additional overhead, e.g., Graphics Effects (Gfx), High Performance Computing (HPC), etc. that are not used in ML applications. A Field Programmable Gate Array (FPGA) also has significant overhead, since it needs to support burning in any form of logic or algorithm into the programmable gate arrays. This reduces hardware efficiency for Machine Learning algorithms where the logic that needs to be implemented is a much smaller subset of all forms of logic or algorithm. Moreover, FPGA is low on programmability, since the constraints of fitting a logic or algorithm into available gate capacity of an FPGA (which can vary for different FPGAs) places limits on size, type and scope of the algorithms that can be mapped into FPGA. An Application Specific Integrated Circuit (ASIC) may be efficient, but it is not flexible to adapt to the changing algorithms and environment required for ML applications. A need has arisen for a new hardware architecture that is highly efficient, with reduced overhead, while flexible and adaptable to the changing environment and algorithms of ML applications. Moreover, a need has arisen for a new instruction set architecture to reduce the number of instructions required to perform certain tasks, e.g., processing, moving data, loading data, etc.
The foregoing examples of the related art and limitations related therewith are intended to be illustrative and not exclusive. Other limitations of the related art will become apparent upon a reading of the specification and a study of the drawings.
Aspects of the present disclosure are best understood from the following detailed description when read with the accompanying figures. It is noted that, in accordance with the standard practice in the industry, various features are not drawn to scale. In fact, the dimensions of the various features may be arbitrarily increased or reduced for clarity of discussion.
The following disclosure provides many different embodiments, or examples, for implementing different features of the subject matter. Specific examples of components and arrangements are described below to simplify the present disclosure. These are, of course, merely examples and are not intended to be limiting. In addition, the present disclosure may repeat reference numerals and/or letters in the various examples. This repetition is for the purpose of simplicity and clarity and does not in itself dictate a relationship between the various embodiments and/or configurations discussed.
Before various embodiments are described in greater detail, it should be understood that the embodiments are not limiting, as elements in such embodiments may vary. It should likewise be understood that a particular embodiment described and/or illustrated herein has elements which may be readily separated from the particular embodiment and optionally combined with any of several other embodiments or substituted for elements in any of several other embodiments described herein. It should also be understood that the terminology used herein is for the purpose of describing the certain concepts, and the terminology is not intended to be limiting. Unless defined otherwise, all technical and scientific terms used herein have the same meaning as commonly understood in the art to which the embodiments pertain.
A new programmable hardware architecture for ML is proposed, which includes at least a host, a memory, a core, a data streaming engine, an instruction-streaming engine, and an interference engine. The core is configured to interpret a plurality of ML commands/instructions for a ML operation and/or data received from the host and coordinate activities of the streaming and the inference engines based on the data in the received ML commands. The inference engine may include a dense operation engine and an irregular operation engine. The dense operation engine is an engine that is optimized to efficiently process dense data with regular operations, e.g., matrix operations such as multiplication, matrix manipulation, tanh, sigmoid, etc. On the other hand the irregular operation engine is an engine that is optimized to efficiently process sporadic data with irregular operations, e.g., memory transpose, addition operation, operations on irregular data structures (such as trees, graphs, and priority queues). According to some embodiments, the core may coordinate some of the instructions received from the host to be processed. In some embodiments, the core may be a general processor, e.g., a CPU, etc.
Specifically, the core is configured to divide the plurality of ML commands between the core and the inference engine for efficient execution thereof. The ML commands and relevant data thereof to be executed by the inference engine are transmitted from the core and the memory to the instruction-streaming engine and the data streaming engine for efficient streaming to the inference engine. The data and instruction steaming engines are configured to send one or more data streams and ML commands to the inference engine in response to the received programming instructions from the core. It is appreciated that, in some embodiments, the ML commands being transmitted from the core to the data/instruction-streaming engines is in a function call format, therefore enabling different processors with different instruction set architectures to be programmed using one type of instruction set architecture. To the core, the operation being performed is a write operation into a memory component, but in reality the operation being done is passing on specific instructions along with their associated data via a function call to the streaming engines for transmission to the inference engine where they can be executed. The inference engine is configured to process the instruction/data streams received from the data/instruction stream engines for the ML operation according to the programming instructions received from the instruction/data streaming engines.
The proposed ML hardware architecture is highly efficient, flexible and optimized for high-efficiency ML computing while programmable to adapt to the changing environment, usage, applications and algorithms for ML with reduced overhead. By providing hardware support to streamline data/instruction flow, the proposed ML hardware architecture improves system-level performance by significantly reducing the hardware overhead involved in moving data and/or instruction in existing computing architectures. Moreover, the programming instruction set reduces the number of instructions required to perform certain tasks, e.g., processing, moving data, loading data, etc. The proposed ML hardware architecture works well with existing software frameworks and code and may be applied to a wide variety of ML algorithms and neural networks including but not limited to convolution neural network (CNN), recurrent neural network (RNN), gradient boosting machine (GBM), generative adversarial neural network, decision trees, random forest, support vector machine (SVM), clustering, Markov random field (MRF), etc.
In the example of
The dense operation engine 161 is an engine that is optimized to efficiently process dense data with regular operations, e.g., matrix operations such as multiplication, matrix manipulation, tanh, sigmoid, etc. On the other hand the irregular operation engine 163 is an engine that is optimized to efficiently process sporadic data with irregular operations, e.g., memory transpose, addition operation, operations on irregular data structures (such as trees, graphs, and priority queues). According to some embodiments, the core may coordinate some of the instructions received from the host to be processed by the general processor 165, e.g., a CPU, etc.
In the example of
In the example of
In the example of
In some embodiments, the core 130 is configured to execute any software code written through a common high-level language. The core 130 is configured to process a plurality of performance non-critical operations, e.g., data/instruction preparatory work, data collection, data mapping, etc. In some embodiments, the core 130 may also be configured to breakdown the received ML commands into performance critical and noncritical operations/tasks such that the performance noncritical operations can be processed by the core 130 and the performance critical operations (e.g., matrix multiplication) can be processed by the inference engine 160. In other words, the core 130 is configured to divide the plurality of ML commands between the core 130 and the inference engine 160 for efficient execution thereof. In some embodiments, the core 130 may also be configured to assign/divide the plurality of ML commands (also referred to as tasks or sub-tasks) to various components, e.g., the inference engine 160, for processing. In some embodiments, the core 130 is configured to allocate one or more locations in the memory 120 for storing of tasks/commands, the data, result after the data is processed, etc. to be accessed and used by the core 130 or other components, e.g., inference engine 160, in the architecture 100. As such, the core 130 and the inference engine 160 are configured to execute the entire ML algorithms and the operation by themselves instead of having to rely on or require the host 110 to execute certain ML commands or operations. By supporting and executing the entire ML operation on the programmable hardware architecture 100, the core 130 eliminates performance overhead of transferring data to the host 110 and back to execute any non-supported ML operations and reduces burden on the host 110 to achieve a higher performance.
The ML commands and relevant data thereof to be executed by the inference engine 160 is transmitted from the core 130 and the memory 120 to the instruction-streaming engine 150 and the data streaming engine 140 for efficient streaming to the inference engine 160. The data/instruction steaming engines 140-150 are configured to send one or more data streams and programming instructions to the inference engine 160 in response to the received ML commands from the core 130. In some embodiments, the core 130 is configured to execute one or more library function calls. For a non-limiting example, a library function call used by the core 130 may be a load command having various parameters, wherein the core 130 may pass certain parameters to the instruction-streaming engine 150 via the library function call. Passing of instructions and their associated data from the core 130 and the memory 120 to the inference engine 160 via a function call enables different processors with different instruction set architectures to be programmed using a single type of instruction set architecture. In other words, for core 130 the operation being performed is a write operation into a special memory location, i.e. instruction-streaming engine 150, but in reality the operation being done is passing on specific instructions along with their associated data to the streaming engines 140-150, via a function call, for transmission to the inference engine 160 where they can be executed and processed. Accordingly, the function call provides a mechanism to seamlessly merge more than one instruction set architecture using a single instruction set architecture by encapsulating the instruction within the function call and providing the instruction as data to the special memory location, i.e. instruction-streaming engine 150, inference engine 160, etc. where it can be processed. The inference engine 160 is configured to process the data/instruction streams received from the data/instruction stream engines 140-150 for the ML operation according to the programming instructions received.
In some embodiments, the instruction-streaming engine 150 is configured to use the parameters provided by the core 130, via a function call, to stream the ML commands in a specific instruction set architecture format of the inference engine 160 to the inference engine 160. Similarly, the data streaming engine 140 is configured to fetch the data stored in the memory 120 based on the parameters provided by the core 130, via a function call, to stream the data in a specific instruction set architecture format of the inference engine 160 to the inference engine 160. It is appreciated that the ML commands in the specific instruction set architecture format and the data are streamed in such a way to reduce the number of required operations. For a non-limiting example, a conventional CPU may require a load, process, and store in order to move one piece of data from one location to the next, however, in some embodiments a streaming mechanism may be used such that data and/or instructions are streamed in a continuous fashion without a need to execute three instructions for each piece of data. For a non-limiting example, the received parameters may be used by the instruction-streaming engine 150 to configure the data streaming engine 140 to achieve the streaming load instruction as described in
In some embodiments, the core 130 is configured to break down a top-level task, e.g., a ML operation, specified by the command from the host 110 into a plurality of sub-tasks and instructor program other components/blocks on the architecture 100, e.g., the data streaming engine 140, the instruction-streaming engine 150, the inference engine 160, to execute those sub-tasks in a coordinated fashion. In some embodiments, the core 130 processes performance non-critical operations. Other instructions that are performance critical operations are passed in a function call from the core 130 to the data streaming engine 140 and/or the instruction-streaming engine 150. Programmer having knowledge of the inference engine 160 architecture, can pass the performance critical operations to the inference engine 160. The sub-tasks and their associated data may therefore be streamed, using the instruction-streaming engine 150 and the data streaming engine 140, to the inference engine 160, thereby programming the inference engine 160, as desired. It is appreciated that two exemplary embodiments of the inference engine 160 architectures are shown in
Once programmed, these components/blocks within the inference engine 160 are responsible for executing the sub-tasks and thus save considerable amount of time and load from the host 110. It is appreciated that, once the command is broken down to the sub-tasks, certain sub-tasks are being executed by the core 130 itself but commands for other sub-tasks that are highly specialized and require high performance efficiency are transmitted to the instruction-streaming engine 150, in a function call. In some embodiments, commands for other sub-tasks that are highly specialized may have a different instruction set architecture and appear to the core 130 as data being written to a special memory location but in reality the special memory component is the instruction-streaming engine 150. The instruction-streaming engine 150 may use the instructions received with the different instruction set architecture with, for non-limiting examples, one or more of different addressing modes, different instructions, different native data types, different registers, different memory architecture, different interrupts, etc., to stream the sub-tasks and any data associated therewith to the inference engine 160 for execution and further processing. It is further appreciated that the core 130 may generate certain sub-tasks that occur at a frequency less than every cycle for certain components of the architecture 100, thereby allowing such components to run at a lower frequency than the rest of the architecture 100, if needed. In some embodiments, any sub-task or programming instructions that are infrequent is executed by the core 130 while repetitive and more frequent programming instructions are executed by a dedicated component of the architecture 100, e.g., inference engine 160. The following is an exemplary software code where every sub-task prior to the “LoadAregfromMainMem” is executed by the core 130 and everything after is executed by the inference engine 160.
Traditionally, one load instruction is typically needed to load each chunk of data from a memory. In the example of
It is appreciated that transmitting the sub-tasks from the core 130 to the instruction engine 150 using non-cacheable address is very slow. Other methods may require a huge overhead. Referring now to
Two pointers may be used, one, e.g., a head pointer, by the core 130 and maintained by the core 130 while a second pointer, e.g., a tail pointer, may be used by the PE/POD instruction streamer 310 and maintained by the instruction streaming engine 150. The head pointer may point to the location where core 130 writes to the buffer 330 while a tail pointer may point to the location where the PE/POD instruction streamer 310 reads from the buffer 330. According to some embodiments, the head and tail pointers are stored in a memory mapped input/output (MMIO) space that is mapped into registers in the PE/POD instruction streamer 310.
In operation, the core 130 maintains a local copy of the head pointer and increments it each time it writes a sub-task into the buffer 330. Similarly, the PE/POD instruction streamer 310 maintains a local copy of the tail pointer and increments it each time it reads a sub-task from the buffer 330. It is appreciated that the core 130 does not read the pointer from the MMIO space because it is the only component that writes to the buffer 330 and therefore its local copy of the head pointer is the most up to date pointer. In some embodiments, the core 130 also maintains the available buffer size where it is decremented every time the core 130 writes instructions, e.g., sub-tasks, to the buffer 330. A predefined threshold may be used to identify when the buffer 330 is running low in buffer space. For example, as long as the available buffer size is greater than the threshold, the core 130 continues to write to the buffer and update the head pointer and the available buffer size, thereby eliminating the need for using non-cacheable address and large overheads. However, if the available buffer size is below the threshold the core 130 reads the MMIO of the tail pointer and resets the available buffer size. In some embodiments, the available buffer size may be set to the buffer size plus the tail pointer minus the head pointer and the result modulo to the actual buffer size. The core 130 continues writing to the buffer 330 until the available buffer size falls below the threshold.
In some embodiments, the PE/POD instruction streamer 310 compares the head pointer to the tail pointer and calculated the amount of buffer to continue to read from. For example, the amount of buffer size to read from may be calculated to be the buffer size plus the head pointer minus the tail pointer and the result modulo the actual buffer size. Thus, the PE/POD instruction streamer 310 continues reading from the buffer 330 and incrementing the tail pointer as long as the buffer size to read from is greater than zero because the head and the tail pointers are local to the PE/POD instruction streamer 310. Accordingly, sub-tasks are streamed from the core 130 to the PE/POD instruction streamer 310, efficiently, expeditiously, and with minimal overhead.
In the example of
In some embodiments, a plurality of processing tiles forms a processing block, e.g., tiles 0-3 forms processing block 1 and the processing tiles within each processing block are coupled to one another via a routing element, e.g., tiles 0-3 are coupled to one another via routing element 440 to form processing block 1. It is appreciated that the processing blocks may be coupled to one another in the same row or column via a plurality of routing elements. For the example as shown in
In some embodiments, the OCM in each processing tile may include a number of memory blocks of any size each having one or more read and write ports (not shown). Each OCM block may further include a read queue and a write queue, which buffer the read and write requests of data stored in the OCM, respectively. In some embodiments, the OCMs of processing tiles in the same processing block support aligned-reads, wherein data allocated and maintained in these OCMs can be retrieved directly to the corresponding PODs or PEs in the tiles via at least one read port in each of the OCMs aligned with the corresponding input lanes in the PODs or PEs. Such aligned-reads minimizes data swizzles for ML operations, e.g., common matrix multiply operations, on data distributed across multiple processing tiles to reduce both the power and the latency of reading data into the PODs or PEs. Here the data to be read needs to be allocated in the OCMs is such a way that aligned-reads work, e.g., the data may be allocated by breaking down its address (X bits) into POD/PE no. (X-Y bits) and OCM address (Y bits). It is appreciated that the specific implementation discussed is for illustration purposes only and should not be construed as limiting the scope of the embodiments.
In some embodiments, the crossbar 510 is configured to support merging of read and/or write requests to the exact same address in the same OCM. Specifically, if a read request reaches an OCM and finds an earlier read request to the same address is waiting at that OCM, the crossbar 510 merges the new read request with the waiting read request at the OCM and terminates the new read request. When data is read and returned for this merged read request, the data is copied n-times and sent to the n-waiting requesters for that data. When a write request matches an earlier write request to the same address at an OCM, the two write data requests are merged and the valid bits of the new write request are updated accordingly. If a read request matches a write request at an OCM, completely or partially, or vice versa, the second request is blocked until the first request is completed. If the first request is a read request, the second write request waits until the read data is returned. If the first request is a write request, the second read request waits until the data has been written by the first request before reading data from the OCM to ensure that the read request picks up the latest data at the OCM.
In the example of
In the example of
During the matrix multiplication process, the matrix multiplication block 602 is configured to read elements of matrices A and B from the OCM only once (instead of reading each row or column of the matrices repeatedly) into the A and B registers, respectively, and thus saves memory access time to the OCM. Specifically, each matrix multiply operation has an inherent structure to it where a row of first matrix will multiply with all columns in second matrix and a column in second matrix will multiply with all rows in first matrix. As the matrix multiplication block 602 performs the matrix multiply operation, each row of the A registers 604 stays the same while the columns of the B registers 606 are fed into the matrix multiplication block 602 one at a time to be multiplied by the row in the A registers 604. At the same time, each column of the B registers 606 stays the same while the rows of the A registers 604 are fed into the matrix multiplication block 602 one at a time to be multiplied by the column of the B registers 606. As such, the matrix multiplication block 602 is configured to simultaneously multiply each row of the first matrix with all columns of the second matrix and each column of the second matrix with all rows of the first matrix. These outputs from these multiplications are accumulated and stored in the C registers until the matrix multiplication process is complete.
As shown in the example of
When the matrix multiplication is complete, e.g., when end of row for A matrix and end of column for B matrix are reached, the matrix multiplication block 602 informs the C registers 608 that all accumulations in the entries of the C registers 608 are complete and the entries are ready to be written back to the OCM via its corresponding streamer 607. Each bank of the C registers 608 will then send data to the OCM. If the OCM is not ready to accept the data from a bank of the C registers 608, the send is stalled and tried again in the next cycle, until the PE is ready to accept the data from the bank. In some embodiments, the C registers 608 are preloaded with data or are reset to zero before next set of accumulations during the next matrix multiplication operation. Such preloading allows for adding bias as part of the next matrix multiplication. In some embodiments, each PE is configured to accept, process, and write output C matrix from the matrix multiplication block 602 of the POD into the OCM.
In some embodiments, the inference engine 160 is configured to fuse/integrate these post matrix multiplication operations by each PE with the matrix multiplication operation by the corresponding POD so that these post matrix multiplication operations are performed immediately on the output from the matrix multiplication block 602 without having to transmit and save the output to the OCM first and to read the C matrix from the OCM again for these post matrix multiplication operations. By bypassing the roundtrip to the OCM, the fusion of the post matrix multiplication operations with the matrix multiplication operation saves time improves efficiency of the inference engine 160. For example, it is appreciated that in some embodiments, additional regular operations, e.g., rectified linear unit (RELU), quantization, etc., may be required on the output C matrix. Thus, a switching mechanism may be integrated within the POD architecture to determine whether additional regular operations are required and if so instead of writing the output C matrix to another memory location the output is operated on. For example, when a rectified linear operation is required the output C matrix is streamed into the RELU unit 610 configured to perform a ReLU operation on the C matrix. Similarly, when a quantization is required the output C matrix or the output of the RELU unit 610 is streamed into a quantization unit 612 configured to quantize the C matrix or a result from the RELU operations. In some embodiments, the scale, shift, and/or offset values needed for the quantization operation may be set statically by the core 130 and may be different from different ML operations. In some embodiments, these values may be part of a ML model downloaded to the core, wherein the values corresponding to the ML operation may be read from the model and written into appropriate registers before the quantization operation starts. It is appreciated that other operations, e.g., TANH, SIGMOID, NOOP, etc., may similarly be integrated within the POD to achieve further efficiencies. For example, in some embodiments, the POD may further include a tanh/sigmoid unit 614 configured to perform one or more per-element operations including but not limited to tanh, sigmoid, and divide operations, on the output from the matrix multiplication block 602, the RELU 601 and/or the quantization unit 612 before writing the output to the OCM. In some embodiments, the tanh/sigmoid unit 614 is configured to perform the per-element operations on the output via a lookup table, wherein values of the lookup table can be preloaded into the tanh/sigmoid unit 614 from the memory 120 by the core 130. The tanh/sigmoid unit 614 is configured to determine a corresponding value of the operation by looking up a value x from the lookup table. Since different sections and models may be used to proximate the per-element operations based on numerical analysis, multiple lookup tables may be utilized for the per-element operations. In other words, the operation may be divided into multiple sections, where each section may be represented by a curve that is extrapolated. Thus, knowing the x value tanh may be determined by referencing the associated section and fetching the value from the table accordingly.
In the example of
As presented above, PEs and PODs may be programmed, as desired. In the example of
In some embodiments, the ISA enables programming of each component, e.g., POD or PE, of the inference engine 160 in three steps: (i) programming one or more input data streams to the component to fetch input data into queues or registers associated with a computing block/operator of the component; (ii) programming the operator to perform the operations to be performed on the input data streams; and (iii) programming one or more output data streams to write the output of the operations into the OCM of the inference engine 160.
In some embodiments, the ISA includes at least three classes of programming instructions: (i) programming instructions executed by the PODs, (ii) programming instructions executed by the PEs, and (iii) common programming instructions executed before the tasks are dispatched to either the PODs or the PEs. Note that each of the programming instructions can be executed by one or more or all of the PODs and/or PEs at the same time. The following table summarizes an example of a subset of the instruction set architecture used to program the inference engine 160.
In some embodiments, the programming instructions executed by one or more PODs are configured to perform one or more of: loading data from memory 120 to the A registers 604, loading data from the OCM to the A registers 604, loading data from the OCM to the B registers 606, performing matrix multiplication by the matrix multiplication block 602, storing result from the C registers 608 to the OCM without post processing (e.g., ReLU, quantization, tanh, and/or sigmoid), storing result from the C registers 608 to the OCM after post processing (e.g., ReLU, quantization, tanh, and/or sigmoid), load bias, scale, and/or shift values, and loading the lookup tables for tanh and/or sigmoid operations from the A registers 604. In some embodiments, the data loading instructions are stalled when the registers and/or buffers are full and will resume when there is space to accommodate the data.
In some embodiments, the programming instructions executed by one or more PEs are configured to perform a set of operations listed above to set one or more of one or more input data streams, an output data stream, and the set of operations to be performed by the PE. As shown in the example of
In some embodiments, the common programming instructions executed by one or more the PODs and/or the PEs are configured to allow grouping of a set of instructions into one or more tasks and broadcast the tasks to each of the PODs and/or the PEs. In some embodiments, the common programming instructions executed by one or more the PODs and/or the PEs are configured to allow each of the PODs and/or the PEs to iteratively execute the grouped set of instructions for the tasks in a loop until certain termination conditions are met.
For a neural network such as a convolution neural network (CNN), weights for matrix multiplications can be more than 85% zeros when trained with the intent to increase sparsity. Even without special training, the sparsity in weights is around 60-70%. As such, a huge performance and power improvement may be achieved by exploiting such sparsity. In the example of
In some embodiments, the core 130 is configured to explore sparsity of data to achieve power reduction. Since the zero values in the data naturally reduce toggle in the logic during the ML operation, identifying the sparsity or zero values in the data leads to power reduction. In some embodiments, the core 130 is configured to adopt an elaborative clock gating schemes based on the sparsity of the data to reduce the number of clock cycles, and thus power consumptions by hardware-based programmable architecture 100 during the ML operation.
In some embodiments, the core 130 is configured to explore sparsity of data to amplify bandwidths of the memory 120 and/or the OCMs. Specifically, by storing weights and activation (input data) in compressed form in memory 120 and/or OCM, the core 130 is configured to amplify the effective bandwidth of the memory 120 and/or OCM by reading out more useful data per access compared to the baseline. In some embodiments, the core 130 data may be decompressed before it is fed into the compute engine, if bandwidth amplification is desired.
In some embodiments, the core 130 is configured to explore sparsity of data to reduce computing time by directly feeding the input data in compressed form into the computing logic or processors in PODs and/or PEs of the inference engine 160. Feeding compressed data into the processors allows the same hardware to perform computation on more data in one clock cycle, thereby reducing the amount of time needed to finish the overall computation for the ML operations.
In some embodiments, the core 130 is configured to format and represent sparse data in compressed form/format in one or more of, for non-limiting examples, compressed sparse row (CSR), compressed sparse column (CSC), run length encoding (RLE), etc. In the example of the CSR format, a sparse row is represented as two arrays of same size, one containing all the non-zero values and other containing the column ids of the corresponding values in the first array. CSC is same as CSR except that the compression is done column-wise format for representing sparse data. RLE compresses the sparse vectors by removing all zeros and instead recording the number of zeros between each
In some embodiments, the core 130 is configured to utilize a higher level function to break down the larger matrix multiplication into sub-matrix multiplications that fit into each function call. This higher level function will run on the core and will set all the arguments for the function calls based on the matrix sizes involved in the larger matrix multiplications. The function call stores the results of the matrix multiply, which are in C registers 608, back into OCM. Relu or Tan h or Sigmoid may be performed on each element before writing to the OCM at the end of convolution and Relu operations.
The foregoing description of various embodiments of the claimed subject matter has been provided for the purposes of illustration and description. It is not intended to be exhaustive or to limit the claimed subject matter to the precise forms disclosed. Many modifications and variations will be apparent to the practitioner skilled in the art. Embodiments were chosen and described in order to best describe the principles of the invention and its practical application, thereby enabling others skilled in the relevant art to understand the claimed subject matter, the various embodiments and the various modifications that are suited to the particular use contemplated.
This application claims the benefit of U.S. Provisional Patent Application No. 62/628,130, filed Feb. 8, 2018, and entitled “MACHINE LEARNING SYSTEM,” which is incorporated herein in its entirety by reference. This application claims the benefit of U.S. Provisional Patent Application No. 62/644,352, filed Mar. 16, 2018, and entitled “PROGRAMMING HARDWARE ARCHITECTURE FOR MACHINE LEARNING VIA INSTRUCTION STREAMING,” which is incorporated herein in its entirety by reference. This application claims the benefit of U.S. Provisional Patent Application No. 62/675,076, filed May 22, 2018, which is incorporated herein in its entirety by reference.
| Number | Name | Date | Kind |
|---|---|---|---|
| 7539717 | Hussain | May 2009 | B2 |
| 8117137 | Xu et al. | Feb 2012 | B2 |
| 8175981 | Hawkins et al. | May 2012 | B2 |
| 8284845 | Kovacevic | Oct 2012 | B1 |
| 9645974 | Patil | May 2017 | B1 |
| 9753695 | Mortensen et al. | Sep 2017 | B2 |
| 10186011 | Nurvitadhi et al. | Jan 2019 | B2 |
| 10261786 | Lacy | Apr 2019 | B2 |
| 10380063 | Tang | Aug 2019 | B2 |
| 10558599 | Staudenmaier | Feb 2020 | B2 |
| 10614357 | Lie | Apr 2020 | B2 |
| 10740434 | Duong et al. | Aug 2020 | B1 |
| 20020023118 | Peled et al. | Feb 2002 | A1 |
| 20030204674 | Ryan et al. | Oct 2003 | A1 |
| 20090319996 | Shafi | Dec 2009 | A1 |
| 20140108734 | Kitchin et al. | Apr 2014 | A1 |
| 20140365548 | Mortensen | Dec 2014 | A1 |
| 20160124651 | Sankaranarayanan et al. | May 2016 | A1 |
| 20170316312 | Goyal et al. | Nov 2017 | A1 |
| 20170323224 | Bruestle et al. | Nov 2017 | A1 |
| 20180137668 | Mercati et al. | May 2018 | A1 |
| 20180167083 | Dubey et al. | Jun 2018 | A1 |
| 20180189675 | Nurvitadhi et al. | Jul 2018 | A1 |
| 20180296281 | Yeung et al. | Oct 2018 | A1 |
| 20180314941 | Lie et al. | Nov 2018 | A1 |
| 20190012295 | Yinger et al. | Jan 2019 | A1 |
| 20190205741 | Gupta et al. | Jul 2019 | A1 |
| 20190243800 | Sodani | Aug 2019 | A1 |
| 20190266479 | Singh et al. | Aug 2019 | A1 |
| 20190392297 | Lau et al. | Dec 2019 | A1 |
| Number | Date | Country | |
|---|---|---|---|
| 20190243871 A1 | Aug 2019 | US |
| Number | Date | Country | |
|---|---|---|---|
| 62628130 | Feb 2018 | US | |
| 62644352 | Mar 2018 | US | |
| 62675076 | May 2018 | US |
