Softmax calculation and architecture using a modified coordinate rotation digital computer (CORDIC) approach

Abstract

Apparatus and associated methods relate to providing a modified CORDIC approach and implementing the modified CORDIC approach in SoftMax calculation to reduce usage of hardware resources. In an illustrative example, a system may include (a) a first circuit configured to transform each element Vi of an input vector V into Vi=Vpi+ki·ln 2 to generate a second data set, (b) a second circuit configured to perform exponential calculations on the second data set to generate a third data set that has a first mantissa

Description

TECHNICAL FIELD

Various embodiments relate generally to neural network processing systems.

BACKGROUND

Machine learning is the science of inducing computing systems to act without being explicitly programmed. Classical machine learning includes various clustering and classification techniques, including K—means clustering, linear and logistic regressions, stochastic gradient decent, association rule learning, and the like. Deep learning is a newer frontier in machine learning. Deep learning is a class of machine learning algorithms that uses multiple layers of nonlinear processing units for feature extraction and transformation. Deep learning algorithms can be unsupervised (e.g., pattern analysis) or supervised (e.g., classification). The deep learning algorithm can be implemented using layers of an artificial neural network (ANN) (referred to herein as a “neural network”).

In general, a neural network is a collection of nodes (e.g., the “neurons”) that are connected in a graph. A node in a neural network computes a sum of weighted inputs and adds an optional bias to the sum. The output of the node is a function of the final sum (referred to as an “activation function”). Example activation functions include the sigmoid function, the hyperbolic tangent (tan h) function, the Rectified Linear Unit (ReLU) function, and the identity function. Neural network models are often organized into layers of nodes, which define a specific topology, and corresponding weights and biases. The weights and biases are referred to as network parameters.

In general, a neural network includes an input layer and an output layer and can optionally include one or more hidden layers between the input and output layers. A neural network used in deep learning applications typically includes many hidden layers, which gives rise to the term deep neural network (DNN). The layers of a neural network can be densely connected (e.g., each node in a layer is fully connected to all nodes in a previous layer) or sparsely connected (e.g., each node in a layer is connected to only a portion of the nodes in a previous layer). A convolutional neural network (CNN) is a type of DNN that includes one or more sparsely connected layers, referred to as convolutional layers. CNN is well-suited for processing image or video data. Other types of DNNs include recurrent neural network (RNNs), which are well-suited for processing speech and text data.

SUMMARY

Apparatus and associated methods relate to providing a modified Coordinate Rotation Digital Computer (CORDIC) approach and implementing the modified CORDIC approach in SoftMax calculation to reduce the usage of hardware resources. In an illustrative example, a system may include (a) a first circuit configured to transform each element V_i of an input vector V into V_i=V_pi+k_i·ln 2 to generate a second data set, (b) a second circuit configured to perform exponential calculations on the second data set to generate a third data set that has a first mantissa

$\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}$ and an exponent K_total, (c) a third circuit configured to perform logarithm calculations to generate a third sub data set that has a second mantissa

$2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right),$ and, (d) a fourth circuit configured to perform exponential calculations to generate an output data set that has

$2^{k_i-k_{\mathrm{total}}}·f_{\exp }(V_{\mathrm{pi}}+2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right),$ the output data set may be interpreted as a probability distribution of each element V_i of the input vector V.

Various embodiments may achieve one or more advantages. In some embodiments, the modified CORDIC approach may be achieved by avoiding the calculation of multiplication and division. For example, some embodiments may implement the modified CORDIC approach in hardware to reduce hardware resources usage in, for example, silicon area by reducing the usage of multipliers and division circuits. Some embodiments may implement the modified CORDIC approach in software, allowing for simple instructions to take place (allowing simple processors to execute), without the necessity of implementing multiplications or divisions that might take many more clock cycles to execute. Accordingly, the implementation of SoftMax calculation may be simplified. In some embodiments, the SoftMax calculation with the modified CORDIC approach may be applied in convolutional neural networks to be used in different technical fields. In some embodiments, hardware resources used to implement the CORDIC approach may be shared to further save hardware sources and reduce the cost of silicon area. In some embodiments, hardware resources may be programmed to provide a programmable architecture with different resolutions.

In an exemplary aspect, a system includes (a) a first circuit configured to receive an input vector V representative of a first data set and transform each element Vi of the input vector V into V_i=V_pi+k_i·ln 2 to generate a second data set, the second data set comprising a first sub data set that has V_pi and a second sub data set that has k_i, −1≤V_pi≤1, and each k_i is an integer. The system also includes (b) a second circuit configured to receive the second data set from the first circuit and perform exponential calculations on the second data set to generate a third data set, the third data set comprising a third sub data set that has a first mantissa

$V_{\mathrm{total}1}=\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}$ and a fourth sub data set having a first exponent k_total, −1≤V_total1≤1. The system also includes (c) a third circuit configured to receive the third sub data set and perform logarithm calculations on the third sub data set to generate a fifth sub data set that has a second mantissa

$V_{\mathrm{total}2}=2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right),-1\le V_{\mathrm{total}2}\le 1.$ The system also includes (d) a fourth circuit configured to receive the fourth sub data set that has the first exponent k_total, the fifth sub data set that has the second mantissa, and the second data set that has V_pi and k_i, and perform exponential calculations to generate an output data set that has

$2^{k_i-k_{\mathrm{total}}}·f_{\exp }(V_{\mathrm{pi}}+2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right),$ the output data set is representative of a probability distribution of each element V_i of the input vector V.

In some embodiments, the first circuit may also include (1) a demultiplexer configured to receive each element V_i of the input vector V representative of the first data set, (2) K_int transformation circuits commonly coupled to the output of the demultiplexer to perform sequential subtraction of value In2 to an absolute value of element V_i, (3) K_int casting circuits, each casting circuit of the K_int casting circuits may be coupled to a transformation circuit of the K_int transformation circuits, and, (4) a multiplexer coupled to receive outputs from the K_int transformation circuits and outputs from the K_int casting circuits to generate the first sub data set that has V_pi and the second sub data set that has k_i.

In some embodiments, the first circuit may also include a data store configured to store the first sub data set that has V_pi and the second sub data set that has k_i. In some embodiments, the second circuit may also include (1) a first N-stage pipelined CORDIC circuit configured to receive the first sub data set that has V_pi and perform exponential calculations on the received V_pi to generate a sixth sub data set that has f_exp(V_pi), (2) a delay circuit configured to introduce a delay on the received the second sub data set that has k_i to match a delay introduced by the first N-stage pipelined CORDIC circuit, and (3) a state machine coupled to the first N-stage pipelined CORDIC circuit and the delay circuit to perform operations on the sixth sub data set to make an integer part of f_exp(V_pi)≤1. In some embodiments, the operations may also include right shifting f_exp(V_pi) and increasing a corresponding k_i if f_exp(V_pi)>1.

In some embodiments, the second circuit may also include (4) a floating point adder coupled to the state machine to perform summation on every f_exp(V_pi), and (5) a floating point register coupled to the floating point adder to generate and store the third sub data set and the fourth sub data set. In some embodiments, the third circuit may also include a second N-stage pipelined CORDIC circuit coupled to the floating point register to receive the third sub data set that has the first mantissa

$V_{\mathrm{total}1}=\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}$ and perform logarithm calculations on the first mantissa V_total1 to generate the fifth sub data set that has the second mantissa

$V_{\mathrm{total}2}=2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right).$

In some embodiments, the fourth circuit may also include (1) a summing circuit configured to retrieve the first sub data set that has V_pi from the data store and retrieve the fifth sub data set that has the second mantissa V_total2 from the floating point register and generate a seventh sub data set, (2) a subtracting circuit configured to retrieve the second sub data set that has k_i from memory and retrieve the fourth data set that has the exponent K_total from the floating point register and subtract the exponent K_total from k_i to generate an eighth sub data set, (3) a N-stage pipelined CORDIC circuit coupled to the output of the summing circuit and configured to perform exponential calculations on the seventh sub data set to generate a ninth sub data set that has

$f_{\exp }(V_{\mathrm{pi}}+2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right),$ (4) a second delay path configured to introduce a delay on the received eighth sub data set, and, (5) a state machine coupled to the N-stage pipelined CORDIC circuit and the delay path to perform operations on the ninth sub data set to make an integer part of

$f_{\exp }(V_{\mathrm{pi}}+2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right),$ ≤1 and generate the output data set.

In another exemplary aspect, a system includes a processing engine and a data storage device coupled to the processing engine and containing a program of instructions that, when executed by the processing engine, cause the processing engine to perform operations to conduct SoftMax calculation, the operations includes (a) receiving an input vector V representative of a first data set and transforming each element V_i of the input vector V into V_i=V_pi+k_i·ln 2 to generate a second data set, the second data set comprising a first sub data set that has V_pi and a second sub data set that has k_i, −1≤V_pi≤1, and k_i is an integer, (b) performing exponential calculations on the second data set to generate a third data set, the third data set comprising a third sub data set that has a first mantissa

$V_{\mathrm{total}1}=2f_{\ln }\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}$ and a fourth sub data set having a first exponent k_total, −1≤V_total≤1, (c) performing logarithm calculations on third sub data set (225a) to generate a fifth sub data set that has a second mantissa

$V_{\mathrm{total}2}=2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right),$ and, (d) receiving the fourth sub data set that has the first exponent k_total, the fifth sub data set that has the second mantissa, and the second data set that has V_pi and k_i, and performing exponential calculations to generate an output data set that has

$2^{k_i-k_{\mathrm{total}}}·f_{\exp }(V_{\mathrm{pi}}+2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right),$ the output data set is representative of a probability distribution of each element V_i of the input vector V.

In some embodiments, the operations may also include (a1) performing sequential subtraction of value In2 to an absolute value of element V_i. In some embodiments, the operations may also include storing the first sub data set that has V_pi and storing the second sub data set that has k_i in the data storage device. In some embodiments, the operations may also include storing the first sub data set that has V_pi and storing the second sub data set that has k_i in memory.

In some embodiments, the operations may also include (b1) performing exponential calculations on the received first sub data set that has V_pi to generate a sixth sub data set that has f_exp(V_pi) and (b2) if f_exp(V_pi)>1, right shifting f_exp(V_pi) and increasing a corresponding k_i to make an integer part of f_exp(V_pi)≤1.

In some embodiments, the operations may also include (b3) performing summation on every f_exp(V_pi), and, (b4) generating and storing the third sub data set and the fourth sub data set. In some embodiments, the operations may also include (c1) retrieving the third sub data set that has the first mantissa

$V_{\mathrm{total}1}=\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}$ and performing logarithm calculations on the first mantissa V_total1 to generate the fifth sub data set that has the second mantissa

$V_{\mathrm{total}2}=2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right).$

In another exemplary aspect, a method includes (a) receiving, by a first circuit, an input vector V representative of a first data set and transforming each element V_i of the input vector V into V_i=V_pi+k_i·ln 2 to generate a second data set, the second data set comprising a first sub data set that has V_pi and a second sub data set that has k_i, −1≤V_pi≤1, and k_i is an integer, (b) receiving, by a second circuit, the second data set from the first circuit and performing exponential calculations on the second data set to generate a third data set, the third data set comprising a third sub data set that has a first mantissa

$V_{\mathrm{total}1}=\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}$ and a fourth sub data set having a first exponent k_total, −1≤V_total≤1, (c) receiving, by a third circuit the third sub data set, and performing logarithm calculations on third sub data set to generate a fifth sub data set that has a second mantissa

$V_{\mathrm{total}2}=2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right),$ and, (d) receiving, by a fourth circuit, the fourth sub data set that has the first exponent k_total, the fifth sub data set that has the second mantissa, and the second data set that has V_pi and k_i, and performing exponential calculations to generate an output data set that has

$2^{k_i-k_{\mathrm{total}}}·f_{\exp }(V_{\mathrm{pi}}+2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right),$

the output data set is representative of a probability distribution of each element V_i of the input vector V.

In some embodiments, the method may also include (a1) receiving, by a demultiplexer, each element V_i of the input vector V representative of the first data set, and (a2) performing, by K_int transformation circuits commonly coupled to the output of the demultiplexer, sequential subtraction of value In2 to an absolute value of element V_i. In some embodiments, the method may also include (b1) performing exponential calculations on the received first sub data set that has V_pi to generate a sixth sub data set that has f_exp(V_pi), and, (b2) if f_exp(V_pi)>1, right shifting f_exp(V_pi) and increasing a corresponding k_i to make an integer part of f_exp(V_pi)≤1.

In some embodiments, the method may also include (b3) performing summation on every f_exp(V_pi), and, (b4) generating and storing the third sub data set and the fourth sub data set. In some embodiments, the method may also include (c1) retrieving the third sub data set that has the first mantissa

$V_{\mathrm{total}1}=\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}$ and performing logarithm calculations on the first mantissa V_total1 to generate the fifth sub data set that has the second mantissa

$V_{\mathrm{total}2}=2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right).$

The details of various embodiments are set forth in the accompanying drawings and the description below. Other features and advantages will be apparent from the description and drawings, and from the claims.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 depicts an exemplary programmable integrated circuit (IC) on which the disclosed circuits and processes may be implemented.

FIG. 2 depicts an exemplary modified Coordinate Rotation Digital Computer (CORDIC) engine implemented in a SoftMax layer of a convolutional neural network.

FIG. 3 depicts an exemplary vector conversion engine of the modified CORDIC engine.

FIG. 4A depicts a first exemplary rotation mode engine of the modified CORDIC engine.

FIG. 4B depicts an exemplary unit cell implemented in rotation mode.

FIG. 4C depicts another exemplary unit cell implemented in rotation mode.

FIG. 5A depicts an exemplary vectoring mode engine of the modified CORDIC engine.

FIG. 5B depicts an exemplary unit cell implemented in vectoring mode.

FIG. 5C depicts another exemplary unit cell implemented in vectoring mode

FIG. 6 depicts a second exemplary rotation mode engine of the modified CORDIC engine.

FIG. 7A depicts a block diagram of an exemplary configuration system having a development environment and an implementation environment to implement the modified CORDIC engine in a field programmable gate array (FPGA) device.

FIG. 7B depicts an exemplary method to calculate mantissa and exponent.

FIG. 8A depicts a flow chart of an exemplary design-time fabric reconfiguration method for a modified CORDIC engine.

FIG. 8B depicts a flowchart of an exemplary run-time method for performing SoftMax calculation using a modified CORDIC engine.

FIG. 9 illustrates an exemplary architecture for a System-on-Chip (SOC) on which the disclosed circuits and processes may be implemented.

Like reference symbols in the various drawings indicate like elements.

DETAILED DESCRIPTION OF ILLUSTRATIVE EMBODIMENTS

Apparatus and associated methods relate to providing a modified CORDIC approach and implementing the modified CORDIC approach in SoftMax calculation to reduce usage of hardware resources. In an illustrative example, a system may include (a) a first circuit configured to transform each element V_i of an input vector V into V_i=V_pi+k_i·ln 2 to generate a second data set, (b) a second circuit configured to perform exponential calculations on the second data set to generate a third data set that has a first mantissa

$\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}$ and an exponent K_total, (c) a third circuit configured to perform logarithm calculations to generate a third sub data set that has a second mantissa

$2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right),$ and, (d) a fourth circuit configured to perform exponential calculations to generate an output data set that has

$2^{k_i-k_{\mathrm{total}}}·f_{\exp }(V_{\mathrm{pi}}+2f_{\ln }\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right),$ the output data set may be interpreted as a probability distribution of each element V_i of the input vector V.

To aid understanding, this document is organized as follows. First, an exemplary platform (e.g., an FPGA) suitable to perform SoftMax calculation is briefly introduced with reference to FIG. 1. Second, with reference to FIGS. 2-6, the discussion turns to exemplary embodiments that illustrate architectures of a modified CORDIC engine used to perform the SoftMax calculation. Then, with reference to FIGS. 7A-8B, systems and methods to configure and operate the modified CORDIC engine are discussed. Finally, with reference to FIG. 9, another exemplary platform (e.g., a system-on-Chip (SOC)) suitable to perform SoftMax calculation is briefly introduced.

FIG. 1 depicts an exemplary programmable integrated circuit (IC) on which the disclosed circuits and processes may be implemented. A programmable IC 100 includes FPGA logic. The programmable IC 100 may be implemented with various programmable resources and may be referred to as a System on Chip (SOC). Various examples of FPGA logic may include several diverse types of programmable logic blocks in an array.

For example, FIG. 1 illustrates a programmable IC 100 that includes a large number of different programmable tiles including multi-gigabit transceivers (MGTs) 101, configurable logic blocks (CLBs) 102, blocks of random access memory (BRAMs) 103, input/output blocks (IOBs) 104, configuration and clocking logic (CONFIG/CLOCKS) 105, digital signal processing blocks (DSPs) 106, specialized input/output blocks (I/O) 107 (e.g., clock ports), and other programmable logic 108 (e.g., digital clock managers, analog-to-digital converters, system monitoring logic). The programmable IC 100 includes dedicated processor blocks (PROC) 110. The programmable IC 100 may include internal and external reconfiguration ports (not shown).

In various examples, a serializer/deserializer may be implemented using the MGTs 101. The MGTs 101 may include various data serializers and deserializers. Data serializers may include various multiplexer implementations. Data deserializers may include various demultiplexer implementations.

In some examples of FPGA logic, each programmable tile includes a programmable interconnect element (INT) 111 having standardized inter-connections 124 to and from a corresponding interconnect element in each adjacent tile. Therefore, the programmable interconnect elements taken together implement the programmable interconnect structure for the illustrated FPGA logic. The programmable interconnect element INT 111 includes the intra-connections 120 to and from the programmable logic element within the same tile, as shown by the examples included in FIG. 1. The programmable interconnect element INT 111 includes the inter-INT-connections 122 to and from the programmable interconnect element INT 111 within the same tile, as shown by the examples included in FIG. 1.

For example, a CLB 102 may include a configurable logic element (CLE) 112 that may be programmed to implement user logic, plus a single programmable interconnect element INT 111. A BRAM 103 may include a BRAM logic element (BRL) 113 and one or more programmable interconnect elements. In some examples, the number of interconnect elements included in a tile may depend on the height of the tile. In the pictured implementation, a BRAM tile has the same height as five CLBs, but other numbers (e.g., four) may also be used. A DSP tile 106 may include a DSP logic element (DSPL) 114 and one or more programmable interconnect elements. An 10B 104 may include, for example, two instances of an input/output logic element (IOL) 115 and one instance of the programmable interconnect element INT 111. The actual I/O bond pads connected, for example, to the I/O logic element 115, may be manufactured using metal layered above the various illustrated logic blocks, and may not be confined to the area of the input/output logic element 115.

In the pictured implementation, a columnar area near the center of the die (shown shaded in FIG. 1) is used for configuration, clock, and other control logic. Horizontal areas 109 extending from the column distribute the clocks and configuration signals across the breadth of the programmable IC 100. Note that the references to “columnar” and “horizontal” areas are relative to viewing the drawing in a portrait orientation.

Some programmable ICs utilizing the architecture illustrated in FIG. 1 may include additional logic blocks that disrupt the regular columnar structure making up a large part of the programmable IC. The additional logic blocks may be programmable blocks and/or dedicated logic. For example, the processor block PROC 110 shown in FIG. 1 spans several columns of CLBs 102 and BRAMs 103.

FIG. 1 illustrates an exemplary programmable IC architecture. The numbers of logic blocks in a column, the relative widths of the columns, the number and order of columns, the types of logic blocks included in the columns, the relative sizes of the logic blocks, and the interconnect/logic implementations are provided purely as examples. For example, in an actual programmable IC, more than one adjacent column of CLBs 102 may be included wherever the CLBs 102 appear, to facilitate the efficient implementation of user logic.

Field programmable gate arrays (FPGAs) have been used to implement circuits that can perform different functions. A subset of artificial intelligence (AI), machine learning (ML) encompasses a wide range of methods and algorithms. FPGAs may serve as the hardware platform for implementing machine learning algorithms.

Some matrices may allow an input vector to be rotated by a certain angle (I). In the R² case, the matrix that may rotates counterclockwise an input vector by is:

$\begin{array}{cc}{R}_{\varphi }=\left[\begin{array}{cc}\cos \varphi & -\sin \varphi \\ \sin \varphi & \cos \varphi \end{array}\right]& \left(1\right)\end{array}$ One exemplary hyperbolic rotation matrix in the R² case may be:

$\left[\begin{array}{c}{x}^{\prime }\\ y^{\prime }\end{array}\right]=R_{\mathrm{hyp}\varphi }\left[\begin{array}{c}x\\ y\end{array}\right]=\left[\begin{array}{cc}\cos h\varphi & \sin h\varphi \\ \sin h\varphi & \cos h\varphi \end{array}\right]\times \left[\begin{array}{c}x\\ y\end{array}\right]$ x′=x·cos hϕ+y·sin hϕ  (2a)y′=x·sin hϕ+y·cos hϕ  (2b)

For an input vector

$\begin{array}{cc}\left[\begin{array}{c}x\\ y\end{array}\right]=\{\begin{array}{c}x=\cos h\Phi =\frac{e^{\Phi }+e^{-\Phi }}{2}\\ y=\sin h\Phi =\frac{e^{\Phi }-e^{-\Phi }}{2}\end{array}& \left(3\right)\end{array}$ when hyperbolically rotated by ϕ, the input vector may become:

$\begin{array}{cc}{x}^{\prime }=\cos h\varphi ·\cos h\Phi +\sin h\Phi ·\sin h\Phi =\frac{e^{\varphi }+e^{-\varphi }}{2}·\frac{e^{\Phi }+e^{-\Phi }}{2}+\frac{e^{\varphi }-e^{-\varphi }}{2}·\frac{e^{\Phi }-e^{-\Phi }}{2}=\frac{e^{\varphi +\Phi }}{2}+\frac{e^{-\left(\varphi +\Phi \right)}}{2}=\cos h\left(\varphi +\Phi \right)& \left(4\right)\\ y^{\prime }=\sin h\varphi ·\cos h\Phi +\cos h\varphi ·\sin h\Phi =\frac{e^{\varphi }-e^{-\varphi }}{2}·\frac{e^{\Phi }+e^{-\Phi }}{2}+\frac{e^{\varphi }+e^{-\varphi }}{2}·\frac{e^{\Phi }-e^{-\Phi }}{2}=\frac{e^{\varphi +\Phi }}{2}-\frac{e^{-\left(\varphi +\Phi \right)}}{2}=\sin h\left(\varphi +\Phi \right)& \left(5\right)\end{array}$

Equation (2a) and equation (2b) may also be rewrote:

$\begin{array}{cc}\begin{array}{c}{x}^{\prime }=x·\cosh \varphi +y·\sinh \varphi \\ =\cosh \varphi \left(x+y·\tanh \varphi \right)\end{array}& \left(6\right)\\ \begin{array}{c}{y}^{\prime }=x·\sinh \varphi +y·\cosh \varphi \\ =\cosh \varphi \left(y+x·\tanh \varphi \right)\end{array}& \left(7\right)\end{array}$

As matrix R_hypϕ may rotate by any angle ϕ, the rotation may be decomposed into more elementary rotations ϕ_i, with i∈N. When there is a sequence d_i and ϕ_i, d_i∈{−1, 1}, the following iterative equations may converge to a desired ϕ rotation:

$\begin{array}{cc}{x}_{i+1}=\cosh {\varphi }_i·\left(x_i+y_i·d_i·\tanh {\varphi }_i\right)y_{i+1}=\cosh {\varphi }_i·\left(y_i+x_i·d_i·\tanh {\varphi }_i\right)z_{i+1}=z_i-d_i·{\varphi }_i& \left(8\right)\end{array}$

(x_i+1, y_i+1) may converge to the (x, y) coordinates of an input vector (x₀, Y₀) that has been rotated clockwise or counterclockwise according to the d_i values, with elementary rotations determined by the sequence ϕ_i. If the input vector will be rotated by z₀, then the equation (8) may be used to determine if d_i is 1 or −1. If at a certain iteration, z_i is negative, then d_i=−1. If z_i is positive, then d_i=1. Different d_i values may make the value in z converge to 0 as more iterations are added. In some embodiments, z may be not the one desired to converge to 0, but x or y. For example, if y is selected to converge to 0, then d_i may take values according to the current value of y_i. For example, d_i may be chose to be −1 when y_i is positive, which may make the second iterative equation in the equation (8) converge to 0. Then, equation (6) and equation (7) may become:

$\begin{array}{cc}x=\cos h(a\tan h\left(-\frac{y_0}{x_0}\right))·\left(x_0+y_0·a\tan h\left(-\frac{y_0}{x_0}\right)\right)=\frac{1}{\sqrt{1-{\left(y_0/x_0\right)}^2}}·\left(x_0-y_0^2/x_0\right)=\sqrt{x_0^2-y_0^2}& \left(9\right)\\ y=0& \left(10\right)\\ z=z_0+a\tan h\left(\frac{y_0}{x_0}\right)& \left(11\right)\end{array}$

Two different modes can be derived from these iterative equations. A first mode, Rotation Mode, makes z→0. A second mode, Vectoring Mode, makes y→0 or x→0. And the iterative equations (8) may be then rewritten:x_i+1=x_i+y_i·d_i·f(i)y_i+1=y_i+x_i·d_i·f(i)z_i+1=z_i−d_i·a tan h(f(i))In Rotation Mode Convergence:x_n=A_n⁻¹·(x₀·cos h(z₀)+y₀·sin h(z₀))y_n=A_n⁻¹·(y₀·cos h(z₀)+x₀·sin h(z₀))z_n=0

$\begin{array}{cc}{A}_n=\prod _{i=1}^n\cos h{\varphi }_i\mathrm{Rule}:d_i=-1,\mathrm{when}{z}_i<0;\mathrm{otherwise}{d}_i=1& \left(12\right)\end{array}$ Rule: d_i=−1, when z_i<0; otherwise d_i=1  (12)

In Vectoring Mode Convergence:

$x_n=A_n^{-1}·\sqrt{x_0^2-y_0^2}$ $y_n=0$ $z_n=z_0+a\tan h\left(y_0/x_0\right)$ y _n=0Z_n=Z₀+a tan h(y₀/x₀)Rule:d_i=−1, when y_i>0; otherwise d_i=1

In iterative equations (12), tan hϕ_i is replaced by f(i), and ϕ_i=a tan h(f(i)). This modification only generates the elementary ϕ_i angles using a chosen f(i) sequence and does not change the convergence of the algorithm. The f(i) sequence may have particular characteristics to make the iterative algorithm work. In order to make the iterative algorithm work, any choice ϕ of may be represented as

$\begin{array}{cc}\sum _{i=1}^{+\infty }{d}_i·{\varphi }_i,& \left(13\right)\end{array}$ for a particular range:

$\varphi \in \left[-\sum _{i=1}^{+\infty }{\varphi }_i;\sum _{i=1}^{+\infty }{\varphi }_i\right]$

The boundaries for ϕ's input range may represent the choice of all −1 s or 1s for the d_i sequence. A first condition over sequence ϕ_i is that

$\sum _{i=1}^{+\infty }{\varphi }_i$ converge to provide input boundaries.

$\begin{array}{cc}2·\sum _{i=1}^{+\infty }{d}_i·{\varphi }_i=2·\sum _{i=1}^{+\infty }a\tan \mathrm{hf}\left(i\right)=\sum _{i=1}^{+\infty }\ln \left(\frac{1+f\left(i\right)}{1-f\left(i\right)}\right)\le \sum _{i=1}^{+\infty }\left(\frac{1+f\left(i\right)}{1-f\left(i\right)}\right)-1=\sum _{i=1}^{+\infty }\frac{2·f\left(i\right)}{1-f\left(i\right)}& \left(14\right)\end{array}$

Because of the logarithm calculation, a condition needed for

$f\left(i\right)\mathrm{is}\frac{1+f\left(i\right)}{1-f\left(i\right)}>0.$ Two cases may be possible: (a) both (1+f(i)) and (1−f(i)) are negative, which is incompatible; or (b) both (1+f(i)) and (1−f(i)) are positive, which is compatible. Thus, sequence f(i) may be bounded −1<f(i)<1. By using this condition over f(i), and knowing that f(i) needs to converge to 0 for i→∞, using the limit comparison theorem,

$\sum _{i=1}^{+\infty }\frac{2·f\left(i\right)}{1-f\left(i\right)}$ is bounded, as long as

$\sum _{i=1}^{+\infty }f\left(i\right)$ converges. From equation 14, is concluded that: if −1<f(i)<1 and

$\sum _{i=1}^{+\infty }f\left(i\right)$ converges, then

$\sum _{i=1}^{+\infty }\frac{2·f\left(i\right)}{1-f\left(i\right)}$ will converge. Accordingly, 2·

$\sum _{i=1}^{+\infty }{d}_i·{\varphi }_i$ will converge. The first condition may be concluded as:

$\sum _{i=1}^{+\infty }{\varphi }_i$ needs to converge, which will happen if

$\sum _{i=1}^{+\infty }f\left(i\right)$ converges, with −1<f(i)<1, ∀i.

For iteration (k−1) in Rotation Mode, if at the iteration, the algorithm has already reached a desired angle ϕ, then the choice of the remaining d_i sequence has to be so that

$\sum _{i=k}^{+\infty }{d}_i·{\varphi }_i=0.$ If this condition is not held, then the algorithm may not be able to reach the target rotation. There will be a sequence d_i, for i={k, k+1, k+2, . . . }, so that

$\begin{array}{cc}{\varphi }_{k-1}=\sum _{i=k}^{+\infty }{d}_i·{\varphi }_i=\sum _{i=k}^{+\infty }{\varphi }_i-2·\sum _{\forall i\ge k,s.t.\mathrm{di}=-1}{\varphi }_i& \left(16\right)\end{array}$

In some embodiments, when the iterative algorithm is finally mapped into hardware, a more relaxed condition may be that at least the summation of all of the ϕ_i angles for i≥k will be greater than ϕ_k−1.

A second condition to make the iterative algorithm to work is any element in sequence ϕ_i will be equal or lower than the summation of the remaining ϕ_i values. That is:

${\varphi }_k\le \sum _{i=k+1}^{+\infty }{\varphi }_i,\forall k\in N.$

If the iterative algorithm converges, then all of the subsequences representing the distance between the target angle and the current angle in the algorithm will converge to 0. When a condition ϕ_n>ϕ_n+1 is applied, for n>c, with c being a finite constant, there will be a value k such that from iteration k−1 to k, the iteration may always get closer to the target ϕ. The iterative algorithm may be divided into two sequences, one for which i is odd, and the other one for which i is even. For both cases, the subsequences representing the distance to the target ϕ may both converge to 0. When considering ϕ_n>ϕ_n+1, for n>c, with c∈N, and applying f (i):

$\begin{array}{cc}\ln \left(\frac{1+f\left(n\right)}{1-f\left(n\right)}\right)>\ln \left(\frac{1+f\left(n+1\right)}{1-f\left(n+1\right)}\right)\left(1-f\left(n+1\right)\right)·\left(1+f\left(n\right)\right)>\left(1+f\left(n+1\right)\right)·\left(1-f\left(n\right)\right)\Rightarrow f\left(n\right)>f\left(n+1\right)& \left(17\right)\end{array}$

A third condition to make the iterative algorithm to work is that there has to be a value c, for which ϕ_n>ϕ_n+1 when n>c, with c∈N. This is equivalent to ask that there is a value c∈N, for which f(n)>f(n+1), when n>c. For the first condition and the third condition, the condition on ϕ_n may be translated to the condition on f(i). For the second condition, a particular sequence f(i) may be tested to see whether the second condition is satisfied in the ϕ_i domain.

CORDIC (Coordinate Rotation Digital Computer), is a simple and efficient algorithm to calculate hyperbolic and trigonometric functions. For CORDIC sequences, in some embodiments, f(i) may be selected to be 2⁻ⁱ (original CORDIC f(i)=2⁻ⁱ sequence). This sequence may satisfy the first condition and the third condition easily, as

$\sum _{i=i}^{+\infty }{2}^{-i}=1,$ and 2⁻ⁿ>2⁻⁽ⁿ⁺¹⁾. Whether this sequence satisfies the second condition may be checked:

$\begin{array}{cc}{\varphi }_i=a\tan h\left(f\left(i\right)\right)\Rightarrow \sum _{i=k}^{+\infty }{\varphi }_i=\sum _{i=k}^{+\infty }a\tan h\left(f\left(i\right)\right)& \left(18\right)\end{array}$ Taylor expansion around 0 for at atanh

$\begin{array}{cc}\mathrm{atanh}\left(x\right)\mathrm{is}\sum _{n=0}^{+\infty }\frac{x^{2n+1}}{2n+1},& \end{array}$ so

$\begin{array}{cc}\begin{array}{c}\sum _{i=k}^{+\infty }{\varphi }_i=\sum _{i=k}^{+\infty }\mathrm{atanh}\left(f\left(i\right)\right)=\sum _{i=k}^{+\infty }\sum _{n=0}^{+\infty }\frac{{f\left(i\right)}^{2n+1}}{2n+1}\\ =\sum _{n=0}^{+\infty }\frac{1}{2n+1}\left(\sum _{i=k}^{+\infty }{f\left(i\right)}^{2n+1}\right)\end{array}& \left(19a\right)\end{array}$

$\sum _{i=k}^{+\infty }{x}^i=\frac{x^k}{1-x},x<1,$ the equation (19a) may be transformed to:

$\begin{array}{cc}\sum _{i=k}^{+\infty }{\varphi }_i=\sum _{n=0}^{+\infty }\frac{1}{2n+1}·\frac{2^{-k\left(2n+1\right)}}{1-2^{-\left(2n+1\right)}}& \left(19b\right)\\ \begin{array}{c}{\varphi }_{k-1}-\sum _{i=k}^{+\infty }{\varphi }_i=\sum _{n=0}^{+\infty }\frac{1}{2n+1}·2^{-\left(k-1\right)\left(2n+1\right)}-\sum _{n=0}^{+\infty }\frac{1}{2n+1}·\frac{2^{-k\left(2n+1\right)}}{1-2^{-\left(2n+1\right)}}\\ =\sum _{n=0}^{+\infty }\frac{1}{2n+1}·2^{-k\left(2n+1\right)}·\left(2^{\left(2n+1\right)}-\frac{1}{1-2^{-\left(2n+1\right)}}\right)\end{array}& \left(20\right)\end{array}$ As term 2^−k(2n+1)>0, then term

$2^{\left(2n+1\right)}-\frac{1}{1-2^{-\left(2n+1\right)}}$ should be negative which only happens if 2²ⁿ<1 (21), which is not possible. Thus, original CORDIC f(i)=2⁻ⁱ sequence is not satisfying the second condition.

In Rotation mode, if x₀=y₀=1, then:

$\begin{array}{cc}\begin{array}{c}{x}_n=y_n=A_n^{-1}\left(1·\cosh \left(z_0\right)+1·\sinh \left(z_0\right)\right)\\ =A_n^{-1}\left(\frac{e^{z_0}+e^{-z_0}}{2}+\frac{e^{z_0}-e^{-z_0}}{2}\right)=A_n^{-1}·e^{z_0}\end{array}& \left(22\right)\end{array}$ This result shows that in Rotation mode, if x₀=y₀=1, then both x_n and y_n converge to a value proportional to e^z0.

For the case of Vectoring Mode, if z₀=0, then:

$\begin{array}{cc}{z}_n=0+a\tanh \left(y_0/x_0\right)=\frac{1}{2}\ln \left(\frac{y_0/x_0+1}{y_0/x_0-1}\right)=\frac{1}{2}\ln \left(\frac{y_0+x_0}{y_0-x_0}\right)& \left(23\right)\\ \mathrm{And},\mathrm{if}{x}_0=\varphi +1,\mathrm{and}{y}_0=\varphi -1,\mathrm{then}\text{:}{z}_n=a\tanh \left(\frac{\varphi -1}{\varphi +1}\right)=\frac{1}{2}\ln \varphi & \left(24\right)\end{array}$ Thus, z_n will actually converge to a value that is proportional to a logarithmic value.

In one example, f(i) sequence may be:

$\begin{array}{cc}f\left(i\right)=\frac{1}{2},\frac{1}{4}+\frac{1}{8},\frac{1}{4},\frac{1}{8}+\frac{1}{16},\frac{1}{8},\frac{1}{16}+\frac{1}{32},\frac{1}{16},\frac{1}{32}+\frac{1}{64},\frac{1}{32}\dots & \left(25a\right)\end{array}$ i=1,2,3,4,5,6,7,8,9, . . .   (25b)

The values in equation (25a) shows that additional values

$(e.g.,\frac{1}{4}+\frac{1}{8},\frac{1}{8}+\frac{1}{16},\frac{1}{16}+\frac{1}{32},\frac{1}{32}+\frac{1}{64}\dots )$ have been added to the original CORDIC f(i)=2⁻ⁱ sequence. In the original CORDIC f(i) sequence is

$\frac{1}{2},\frac{1}{4},\frac{1}{8},\frac{1}{16},\frac{1}{32}$ etc. in the modified cordic version, there is a change to that sequence. For example, the modified f(i) sequence shown in Equation 25a. In this sequence, intermediate values are used, for example

$\left(\frac{1}{4}+\frac{1}{8}\right).$ In order to achieve a multiplication by this value, the hardware resources are incremented with respect to the original CORDIC implementation. The modified CORDIC engine may be implemented with significantly reduced hardware resources. The modified CORDIC sequence in equation (25a) can be shown to satisfy the second condition. The exponential function is computed in Rotation mode, and the desired input to the exponential function may be represented as

$\sum _{i=k}^{+\infty }{d}_i·{\varphi }_i.$ For example, to calculate the exponential function in [−a; a], the condition is

$\begin{array}{cc}\sum _{i=k}^{+\infty }{\varphi }_i\ge a.& \left(26\right)\end{array}$ The logarithm function is computed in Vectoring mode, and the desired resulted may appear in z_n in equation (12) as may be represented as ½ lnϕ. Then, all values ½ lnϕ may be representable as

$\sum _{i=k}^{+\infty }{d}_i·{\varphi }_i.$ The supported input range for the logarithm calculation may be achieved.

$\begin{array}{cc}-\sum _{i=k}^{+\infty }{\varphi }_i\le \frac{1}{2}\ln \varphi \le \sum _{i=k}^{+\infty }{\varphi }_i{e}^{-2\sum _{i=k}^{+\infty }{\varphi }_i}\le \varphi \le e^{2\sum _{i=k}^{+\infty }{\varphi }_i}& \left(27\right)\end{array}$

FIG. 2 depicts an exemplary modified CORDIC engine implemented in a SoftMax layer of a convolutional neural network. SoftMax is a function that may be used at the output of neural networks (e.g., Convolutional neural networks (CNNs)), and allows for predictions to be non-linearly scaled in such a way that large numbers may be amplified, and small numbers may be attenuated. The equation for SoftMax is:

$\begin{array}{cc}\mathrm{SoftMax}\left(\overrightarrow{V}\right)=\frac{\left(e^{V_1},e^{V_2},\dots ,e^{V_n}\right)}{\sum _{j=1}^n{e}^{V_j}}& \left(28\right)\end{array}$ For a single element in the equation (28),

$\begin{array}{cc}{\mathrm{SoftMax}}_i\left(\overrightarrow{V}\right)=\frac{e^{V_i}}{\sum _{j=1}^n{e}^{V_j}}& \left(29\right)\end{array}$ Values V_i may be assigned any value. In some embodiments, the integer part of V_i may be constrained to [−2^Kint−1; 2^Kint−1], which means K_int bits may be assigned to represent the signed integer part of V_i, with i∈{1, 2, . . . , n}.

A modified CORDIC engine 200 may be used to receive an input vector V representative of an input data set 205 and perform SoftMax computation on the input data set 205 to obtain an output data set 255 that may be interpreted as a probability distribution of each element V_i in the input vector V. In some embodiments, the modified CORDIC engine 200 may also include a data store configured to store the data set 205. In order to compute SoftMax using the Rotation mode and the Vectoring mode of the modified-CORDIC method, which allows to compute both the exponential and logarithm function, every value V_i in {right arrow over (V)} may be transformed to a new representation:V_i=V_pi+k_i·ln2, withV_pi∈(−1,1), k_i∈Z  (30)As V_i∈[−2^Kint−1; 2^Kint−1], a binary search may be performed with values:2^Kint−1·ln2,2^Kint−2·ln2,2^Kint−3·ln2, . . . ,1·ln2  (31)

$\begin{array}{cc}\ln 2·\sum _{i=0}^{K_{int}-1}{2}^i=\ln 2·\frac{1-2^{K_{\mathrm{int}}}}{1-2}=\ln 2·\left(2^{K_{int}}-1\right)\ge 2^{K_{int}}-1& \left(32\right)\end{array}$ Equation (32) shows that with just K_int iterations, for every V_i value, its k_i and the remainder of that iterative search may be assigned to V_pi, which will be a value ∈(−1,1).

The modified CORDIC engine 200, in this depicted example, includes a Vector Conversion Engine (VCE) 210 used to receive the input data set 205 and perform the transformation (shown in equation (30)) to generate a second data set 215 that includes a second-sub1 data set 215a (comprising V_pi) and a second-sub2 data set 215b (comprising k_i). By introducing the VCE 210 with K_int parallel instantiations of the binary search shown in equation (32), a back to back stream of V_i may be translated into a back to back output of values V_pi and k_i. An example of a VCE architecture is described in further detail with reference to FIG. 3. Based on the equation (30), the SoftMax of a single element may be defined as:

$\begin{array}{cc}{\mathrm{SoftMax}}_i\left(\overrightarrow{V}\right)=\frac{e^{V_i}}{\sum _{j=1}^n{e}^{V_j}}=\frac{e^{V_{pi}+k_i·ln2}}{\sum _{j=1}^n{e}^{V_{pj}+k_j·\ln 2}}=\frac{2^{k_i}·e^{V_{pi}}}{\sum _{j=1}^n\left(2^{k_j}·e^{V_{pj}}\right)}& \left(33\right)\end{array}$ SoftMax has been converted into exponential functions, with the V_pi being ∈(−1, 1).

In some embodiments, the Rotation mode of the modified-CORDIC method may be used for exponential calculation, and based on the equation (26), the following constraint may be met for all of the ϕ_i values:Σ_∀iϕ_i>1  (34)Unscaled modified-CORDIC exponential output may be defined as f_exp(V)=e V/An′ where An is the scaling factor in equation (12).

$\begin{array}{cc}{\mathrm{SoftMax}}_i\left(\overrightarrow{V}\right)=\frac{2^{k_i}·e^{V_{pi}}}{\sum _{j=1}^n\left(2^{k_j}·e^{x_{pj}}\right)}=\frac{2^{k_i}·e^{V_{pi}}}{\sum _{j=1}^n\left(2^{k_j}·f_{exp}\left(V_{pj}\right)·\mathrm{An}\right)}& \left(35\right)\end{array}$ By applying the natural logarithm, and after the exponential,

$\begin{array}{cc}\begin{array}{c}{\mathrm{SoftMax}}_i\left(\overrightarrow{V}\right)={e^{ln\left(2^{k_i}·e^{V_{pi}}\right)-\ln (\sum _{j=1}^n\left(2^{k_j}·f_{exp}\left(V_{pj}\right)·\mathrm{An}\right)}}^{}\\ =2^{k_i}·A{n}^{-1}·e^{V_{pi}-\ln (\sum _{j=1}^n\left(2^{k_j}·f_{exp}\left(V_{pj}\right)\right)}\end{array}& \left(36\right)\end{array}$

Every value in the summation

$\sum _{j=1}^n\left(2^{k_j}·f_{\exp }\left(V_{pj}\right)\right)$ may be represented as a floating point number, and a floating point adder may be used to perform the summation. An example of a RME1 architecture is described in further detail with reference to FIG. 4A. The summation

$\sum _{j=1}^n\left(2^{k_j}·f_{\exp }\left(V_{pj}\right)\right)$ may add up to 2^ktotal·V_total. The exponent result after the floating point addition of all of the values may be k_total, the mantissa result after the floating point addition of all of the values may be V_total, and the SoftMax for a single element may be:

$\begin{array}{cc}{\mathrm{SoftMax}}_i\left(\overrightarrow{V}\right)=2^{k_i-k_{total}}·A{n}^{-1}·e^{V_{pi}-\ln \left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{total}}}\right)}& \left(37\right)\end{array}$ The mantissa in the floating point adder holds values up to 1, then the most significant bit (MSB) of that mantissa may be 1, and:

$\begin{array}{cc}\frac{1}{2}\le \frac{\sum _{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}\le 1& \left(38\right)\end{array}$

The modified CORDIC engine 200 includes a first Rotation Mode Engine (RME) 220 configured to perform the exponential calculation on the second data set 215 to obtain a third data set 225. The third data set 225 includes a third-sub1 data set 225a comprising V_total and a third-sub2 data set 225b comprising k_total.

The modified CORDIC engine 200 also includes a floating point register 230 configured to receive the third data set 225 from the RME1 220. The modified CORDIC engine 200 also includes a Vectoring Mode Engine (VME) 240 coupled to the floating point register 230 to perform logarithm function on a third-sub1 data set 225a of the second processed data set 225. The VME 240 generates a fourth-sub1 data set 235a, and the fourth-sub1 data set 235a is then stored in the floating point register 230. An example of an VME architecture is described in further detail with reference to FIG. 5A. To compute the logarithm function using the Vectoring Mode of the modified-CORDIC, the condition may be:

$\begin{array}{cc}-\sum _{\forall i}{\varphi }_i\le -\frac{1}{2}\ln (\frac{\sum _{j=1}^n{2}^{k_j}·f_{e\mathrm{xp}}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}})\le \sum _{\forall i}{\varphi }_i& \left(39\right)\end{array}$ The input to the logarithm function will be ∈[½, 1), and the constraint is:

$\begin{array}{cc}-\ln (\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}\le 2·\sum _{\forall i}{\varphi }_i& \left(40\right)\\ \frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}\ge e^{-2·{\sum }_{\forall i}{\varphi }_i}& \left(41\right)\end{array}$ The smallest value that

$\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}$ may achieve is ½, and the constraint on ϕ_i may then be loosen:

$\frac{1}{2}\ge e^{-2·\sum _i{\varphi }_i}$

$\begin{array}{cc}\Rightarrow \sum _{\forall i}{\varphi }_i\ge \frac{\ln \left(2\right)}{2}& \left(42\right)\end{array}$ This condition on ϕ_i is already satisfied considering the first condition in equation (34). The modified CORDIC method may be used to compute the

$-\frac{1}{2}\ln \left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}\right),$ and the modified CORDIC implementation may be called

$f_{\ln }\left(V\right)=-\frac{1}{2}\ln \left(V\right).$ By satisfying the equation (34), the exponential functions may be performed first, and the logarithm functions may be then performed. The SoftMax of a single element may become:

$\begin{array}{cc}\mathrm{Soft}{\mathrm{Max}}_i\left(\overrightarrow{V}\right)=2^{k_i-k_{total}}·{\mathrm{An}}^{-1}·e^{V_{pi}+2f_{ln}\left(\frac{{\sum }_{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right)}& \left(43\right)\end{array}$ The modified CORDIC may be implemented in Rotation Mode to calculate the exponential function

$e^{V_{pi}+2f_{ln}\left(\frac{{\sum }_{j=1}^n{2}^{k_j}·f_{\exp }\left(V_{\mathrm{pj}}\right)}{2^{k_{\mathrm{total}}}}\right)}.$ The modified CORDIC engine 200 also includes a second Rotation Mode Engine (RME) 250 configured to perform exponential calculations on the second data set 215 and a fourth data set 245 (comprising the fourth-sub1 data set 235a and the third-sub2 data set 225b) to generate the output data set 255. The condition to perform the exponential function is the exponential function may be representable as Σ_∀id_i·ϕ_i.

$\begin{array}{cc}-1\le V_{pi}+2f_{ln}\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}\right)\le 1-\ln \frac{1}{2}=1+\ln 2& \left(44\right)\end{array}$ A stronger constraint on the ϕ_i values may be obtained: Σ_∀iϕ_i≥1+ln 2 (45) As long as the ϕ_i values satisfy the first condition, the second condition, the third condition and the condition shown in (44), the SoftMax of a single element may become:

$\begin{array}{cc}\mathrm{Soft}{\mathrm{Max}}_i\left(\overrightarrow{V}\right)=2^{k_i-k_{total}}·f_{exp}(V_{pi}+2f_{ln}\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}\right)& \left(46\right)\end{array}$ In this depicted example, the floating point register 230 is implemented in the modified CORDIC engine 200. In some embodiments, some parts or all of the floating point register 230 may be implemented in the RME1 220, the VME 240 and/or the RME2 250. For example, the floating point register 230 may be implemented in the RME1 220. Thus, by using the modified CORDIC method that mainly based on shifts and adds, and without the need of any multipliers or dividers, SoftMax calculations may be easily performed. Accordingly, the implementation of SoftMax calculations may advantageously reduce the cost of silicon area. Although, in this depicted example, the RME1 220, the VME 240 and the RME2 250 are discussed as three different circuits, in some embodiments, the RME1 220, the VME 240 and the RME2 250 may be implemented in a single programmable circuit that may perform all of these functions. Thus, hardware resources used to form the modified CORDIC engine to perform SoftMax calculations may be advantageously reduced.

FIG. 3 depicts an exemplary vector conversion engine of the modified CORDIC engine. As discussed before, every element V_i of a vector V in the input data set 205 may be converted into a new representation shown in equation (30). This conversion may be accomplished by performing a sequential subtraction of values ln2 for each V_i element. This conversion, as shown in equation (31), may take K_int clock cycles. The VCE 210 is configured to perform the vector conversion. The values V_i injected into the VCE 210 may be fixed point values, and a number of bits K_int may be used to represent the integer part, and a number of bits K_frac may be used to represent the fractional part of the fixed point values.

In this depicted example, the VCE 210 includes a 1-to-K_int (K_int+K_frac)-bit demultiplexer 305. The demultiplexer 305 is configured to receive V_i. A first selection signal 306 may be used to control the demultiplexer 305. The VCE 210 also includes K_int (e.g., 10) transformation circuits 310₁-310_Kint configured to perform sequential subtraction of the value ln(2) to the absolute value of transformation circuits' inputs V_i. The number of times the subtraction was able to take place will be k_i values, and the remainder will be V_pi. In this depicted example, the number of bits utilized in this case for the precision of the value ln(2) has been chosen to be 24. The choice of 24 may be changed. The K_int transformation circuits 310₁-310_Kint are coupled to the output of the demultiplexer 305. Each transformation circuit 310₁-310_Kint is configured to generate a corresponding first signal 311₁-311_Kint (e.g., 24-bit signal) and a corresponding second signal 312₁-312_Kint. Each of the second signals 312₁-312_Kint is a K_int-bit signal.

The VCE 210 also includes K_int casting circuits 315₁-315_Kint configured to trim the number of precision bits from, for example, 24 bits to C_it+1 bits. The value C_it corresponds to the number of iterations chosen in the CORDIC algorithm. The additional bit in C_it+1 is used to consider the sign bit. Each of the casting circuits 315₁-315_Kint is coupled to a corresponding transformation circuit 310₁-310_Kint to receive a corresponding first signal 311₁-311_Kint and generate a corresponding third signal 318₁-318_Kint.

The VCE 210 also includes a K_int-to-1(K_int+C_it+1)-bit multiplexer 320. The K_int-to-1(K_int+C_it+1)-bit multiplexer 320 is configured to receive the third signals 318₁-318_Kint and the second signals 312₁-312_Kint. A second selection signal 322 may be used to control the multiplexer 320. The multiplexer 320 is configured to output the second data set 215. The second data set 215 includes the second-sub1 data set 215a and the second-sub2 data set 215b. The second-sub1 data set 215a includes (C_it+1)-bit V_pi. The second-sub2 data set 215b includes K_in-bit corresponding k_i. Then, every element V_i is converted into a new representation V_i=V_pi+k_i·ln 2, with V_pi ∈(−1,1), k_i ∈Z shown in equation (30). The VCE 210 also includes memory 330 of N words of (K_int+C_it+1) bits. The memory 330 is configured to receive the second-sub1 data set 215a and the second-sub2 data set 215b. A counter 335 may be used to point to the address in memory 330 where a next bit of the second-sub1 data set 215a and the second-sub2 data set 215b to be stored.

FIG. 4A depicts a first exemplary rotation mode engine of the modified CORDIC engine. The RME1 220 is coupled to the output of the VCE 210 to receive the second data set 215. In this depicted example, the RME1 220 includes a casting circuit 410 configured to cast its (C_it+1)-bit input (e.g., V_pi) into (C_it+Z)-bit input.

The RME1 220 also includes a first pipeline-CORDIC architecture 415 coupled to the output of the casting circuit 410. The first pipeline-CORDIC architecture 415 is configured by cascade-connecting C_it stages of unit cells 420₁-420_Cit. Each stage of unit cell may be configured to work in rotation mode. An exemplary architecture of the rotation mode stage is discussed in further detail with reference to FIG. 4B. Each unit cell 420₁-420_Cit configured to receive four inputs X_in, Y_in, Z_in, ϕ_i, and generate three outputs X_out, Y_out, Z_out. Each unit cell 420₁-420_Cit may introduce one clock cycle delay Z⁻¹. The four inputs X_in, Y_in, Z_in, and ϕ_i are configured to receive input data (e.g., incoming values X_i, Y_i, Z_i, and a corresponding angle ϕ₁˜ϕ_cit, respectively). The incoming values received by the first unit cell 420₁ are 1, 1, V_pi, and ϕ₁.

The RME1 220 also includes a first delay path 425 configured to receive the second-sub2 data set 215b. The first delay path 425 may include one or more delay units connected in series to introduce a delay equal to the delay caused by the first pipeline-CORDIC architecture 415. The RME1 220 also includes a first state machine 430. The first state machine 430 is configured to the output of the first pipeline-CORDIC architecture 415 to receive a sixth signal 423 that includes f_exp(V_pj) and the output of the first delay path 425 to receive a seventh signal 427 that includes a delayed k_i. The first state machine 430 is configured to perform operations to generate an eighth signal 431 that includes f_exp′(V_p1) and a ninth signal 432 in response to the received sixth signal 423 and the received seventh signal 427. The first state machine 430 is configured to make sure that the value of f_exp(V_pj) doesn't have any integer part. If f_exp(V_pj) has an integer part, then f_exp(V_pj) will be shifted and k_i will be increased accordingly, and the eighth signal 431 (e.g., shifted f_exp(V_pj)) and the ninth signal 432 (e.g., increased k_i) are obtained. For example, when f_exp(V_pj)>1, then a shift to the right of up to two positions may be performed, with an increase in the corresponding k_i value. In the first pipeline-CORDIC architecture 415, the exponential calculation is performed, and the maximum input value in input Zin of unit cell 4201 will be the numeric value 1, making the maximum possible output f_exp(V_pj) 2.71=e{circumflex over ( )}1. Thus, the integer part of the result f_exp(V_pj) may be up to 2 (e.g., integer part=0, 1 or 2) and the state machine 430 is configured to perform the transformation only when integer part is 1 or 2 (which maps to the cases of MSBs=‘01’ and MSB=‘1’ in FIG. 4A).

The RME1 220 also includes a summing circuit (e.g., a floating point adder) 440. The summing circuit 440 is configured to receive the eighth signal 431 and the ninth signal 432 from the first state machine 430. Both a tenth signal 441 that includes f_exp(V_pj) and an eleventh signal 442 that includes corresponding k_i value will be added and accumulated for all the samples into the floating point register 230. The final values (e.g., the third data set 225) held by the floating point register 230 may include mantissa V_total (included in a third-sub1 data set 225a) and the exponent k_total (included in a third-sub2 data set 225b), the mantissa

$V_{\mathrm{total}}=\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}.$

FIG. 4B depicts an exemplary unit cell implemented in rotation mode. In the original CORDIC, f(i) sequence is

$\frac{1}{2},\frac{1}{4},\frac{1}{8},\frac{1}{16},\frac{1}{32}\mathrm{etc}.$ In the modified CORDIC version, there is a change to that f(i) sequence. For example, the modified f(i) sequence shown in Equation 25a. In the modified f(i) sequence, intermediate values are used, for example

$\left(\frac{1}{4}+\frac{1}{8}\right).$ In order to achieve a multiplication by this value, the hardware resources are incremented with respect to the original CORDIC implementation. The intermediate values may be used very seldomly so that the three conditions mentioned before are satisfied. When θ_i=1, an exemplary unit cell 420i implemented in the first pipeline-CORDIC architecture 415 includes a first buffer 450a configured to receive x_i, a second buffer 450b configured to receive y_i, and a third buffer 450c configured to receive z_i. x_i, y_i, and z_i represent the respective input values from port X_in, Y_in and Z_in in a given CORDIC stage i. The value θ_i=1 indicates a value that is the interpolation of two consecutive values is in the 2{circumflex over ( )}(−i) sequence. The third buffer 450c is configured to output a first intermediate output signal 451 and a second intermediate output signal 452. The first intermediate output signal 451 includes the MSB of input z_i to identify the sign of the input z_i, and the second intermediate output signal 452 includes the whole input z_i.

The unit cell 420i also includes a first shifter 455a coupled to the output of the first buffer 450a. The first shifter 455a may right shift the input x_i (i−∈(i)+1) bits and then generates a first shifted signal 460a. The unit cell 420i also includes a second shifter 455b coupled to the output of the first buffer 450a. The second shifter 455b may right shift (i−∈(i)) bits of the input x_i and then generates a second shifted signal 460b. The unit cell 420i also includes a third shifter 455c coupled to the output of the second buffer 450b. The third shifter 455c may right shift (i−∈(i)+1) bits of the input y_i and then generates a third shifted signal 460c. The unit cell 420i also includes a fourth shifter 455d coupled to the output of the second buffer 450b. The fourth shifter 455d may right shift (i−∈(i)) bits of the input y_i and then generates a fourth shifted signal 460d.

A first summing circuit 465a receives the third and fourth shifted signal 460c and 460d and generates a first summing signal 467a. The first summing signal 467a is inverted by a first inversion circuit 470a (e.g., an inverter). The first summing signal 467a and the inverted first summing signal 472a are received by a two-input multiplexer 475a. A second summing circuit 465b receives the first and second shifted signal 460a and 460b and generates a second summing signal 467b. The second summing signal 467b is inverted by a second inversion circuit 470b. The second summing signal 467b and the inverted second summing signal 472b are received by a two-input multiplexer 475b.

The first intermediate output signal 451 is used as a selection signal for both the multiplexer 475a and the multiplexer 475b. The multiplexer 475a then generates a first selected signal 478a, the first selected signal 478a and the input signal x_i are received by a third summing circuit 480a to generate a first iteration signal 485a that includes x_i+1. The multiplexer 475b generates a second selected signal 478b, the second selected signal 478b and the input signal y_i are received by a fourth summing circuit 480b to generate a second iteration signal 485b that includes y_i+1. The unit cell 420i also includes a third inversion circuit 470c receives and inverts a first angle signal that includes ϕ_i. The first angle signal ϕ_i and the first inverted angle signal 472c are received by a third multiplexer 475c. The first intermediate output signal 451 is also used as a selection signal for the multiplexer 475c. The multiplexer 475c generates a third selected signal 478c, the third selected signal 478c and first angle signal ϕ_i are received by a fifth summing circuit 480c to generate a third iteration signal 485c that includes z_i+1.

FIG. 4C depicts another exemplary unit cell implemented in rotation mode. When θ_i=0, an exemplary unit cell 420i′ implemented in the first pipeline-CORDIC architecture 415 includes the first buffer 450a configured to receive x_i, the second buffer 450b configured to receive y_i, and the third buffer 450c configured to receive z₁. The value θ_i=0 indicates a value that is the interpolation of two consecutive values is not in the 2{circumflex over ( )}(−i) sequence.

The unit cell 420i′ includes the second shifter 455b coupled to the output of the first buffer 450a. The second shifter 455b may right shift the input x_i (i−∈(i)) bits and then generates the second shifted signal 460b. The unit cell 420i also includes the fourth shifter 455d coupled to the output of the second buffer 450b. The fourth shifter 455d may right shift the input y_i (i−∈(i)) bits and then generates the fourth shifted signal 460d.

The fourth shifted signal 460d is then inverted by the first inversion circuit 470a (e.g., an inverter). The fourth shifted signal 460d and the inverted fourth shifted signal 473a are received by the multiplexer 475a. The second shifted signal 460b is inverted by the second inversion circuit 470b. The second shifted signal 460b and the inverted second shifted signal 473b 472b are received by the multiplexer 475b. The first intermediate output signal 451 is used as a selection signal for both the multiplexer 475a and the multiplexer 475b. The multiplexer 475a then generates a first selected signal 479a, the first selected signal 479a and the input signal x_i are received by the third summing circuit 480a to generate a first iteration signal 490a that includes x_i+1. The multiplexer 475b generates a second selected signal 479b, the second selected signal 479b and the input signal y_i are received by the fourth summing circuit 480b to generate a second iteration signal 490b that includes y_i+1. The unit cell 420i also includes the third inversion circuit 470c receives and inverts the first angle signal that includes ϕ_i. The first angle signal ϕ_i and the first inverted angle signal 472c are received by the third multiplexer 475c. The first intermediate output signal 451 is also used as a selection signal for the multiplexer 475c. The multiplexer 475c generates a third selected signal 478c, the third selected signal 478c and first angle signal ϕ_i are received by the fifth summing circuit 480c to generate the third iteration signal 490c that includes z_i+1.

FIG. 5A depicts an exemplary vectoring mode engine of the modified CORDIC engine. The VME 240 is configured to receive the third-sub1 data set 225a and perform logarithm calculations on the third-sub1 data set 225a to generate a fourth-sub1 data set 235a. In this depicted example, the VME 240 includes a casting circuit 505 casting its (C_it 2)-bit input into (C_it+XY)-bit input. The casting circuit 505 is coupled to the floating point register 230 to receive the mantissa V_total (e.g., the third-sub1 data set 225a). The mantissa V_total is then received by a first subtracting circuit 510a and a fourth summing circuit 510b, respectively. The first subtracting circuit 510a subtracts one from the mantissa V_total to generate a first subtracting signal 512. The fourth summing circuit 510b adds 1 to the mantissa V_total to generate a first summing signal 513.

The VME 240 also includes a second pipeline-CORDIC architecture 515 coupled to the output of the first subtracting circuit 510a and the output of the fourth summing circuit 510b. The second pipeline-CORDIC architecture 515 is configured by cascade-connecting C_it stages of unit cells 520₁-520_Cit. Each stage of unit cell may be configured to work in vectoring mode. An exemplary architecture of the vectoring mode stage is discussed in further detail with reference to FIG. 5B. Each unit cell 520₁-520_Cit includes four inputs X_in, Y_in, Z_in, ϕ_i and three outputs X_out, Y_out, Z_out. The four inputs X_in, Y_in, Z_in, and ϕ_i are configured to receive input data (e.g., incoming values X_i, Y_i, Z_i, and a corresponding angle ϕ₁˜ϕ_cit, respectively). The incoming values received by the four inputs X_in, Y_in, Z_in, ϕ_i of the first unit cell 520₁ are the first summing signal 513, the first subtracting signal 512, 0, and ϕ₁, respectively.

The VME 240 also includes a shifter and trimming circuit 525 coupled to the output Z_out zof the last unit cell 520_Cit in the second pipeline-CORDIC architecture 515 to shift the output Z_out of the last unit cell 520_Cit by one position to achieve the multiplication by 2 required, and trimming the input number of bits from C_it+Z to C_it. The shifter and trimming circuit 525 outputs a logarithm signal (e.g., fourth-sub1 data set 235a) that includes

$2f_{ln}\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}\right).$ The fourth-sub1 data set 235a is then stored in the floating point register 230.

FIG. 5B depicts an exemplary unit cell implemented in vectoring mode. When θ_i=1, an exemplary unit cell 520i implemented in the second pipeline-CORDIC architecture 515 includes a first buffer 550a configured to receive x_i, a second buffer 550b configured to receive y_i, and a third buffer 550c configured to receive z_i. x_i, y_i, and z_i represent the respective input values from port Xin, Yin and Zin in a given CORDIC stage i. The second buffer 550b is configured to output a first intermediate output signal 551 and a second intermediate output signal 552. The first intermediate output signal 551 includes the MSB of input y_i to identify the sign of the input y_i, and the second intermediate output signal 552 includes the whole input y_i.

The unit cell 520i also includes a first shifter 555a coupled to the output of the first buffer 550a. The first shifter 555a may right shift the input x_i (i−∈(i)+1) bits and then generates a first shifted signal 560a. The unit cell 520i also includes a second shifter 555b coupled to the output of the first buffer 550a to receive second intermediate output signal 552 includes the whole input y_i. The second shifter 555b may right shift the input x_i (i−∈(i)) bits and then generates a second shifted signal 560b. The unit cell 520i also includes a third shifter 555c coupled to the output of the second buffer 550b. The third shifter 555c may right shift the input y_i (i−∈(i)+1) bits and then generates a third shifted signal 560c. The unit cell 520i also includes a fourth shifter 555d coupled to the output of the second buffer 550b. The fourth shifter 555d may right shift the input y_i (i−∈(i)) bits and then generates a fourth shifted signal 560d.

A summing circuit 565a receives the third and fourth shifted signal 560c and 560d and generates a first summing signal 567a. The first summing signal 567a is inverted by a first inversion circuit 570a (e.g., an inverter). The first summing signal 567a and the inverted first summing signal 572a are received by a two-input multiplexer 575a. A second summing circuit 565b receives the first and second shifted signal 560a and 560b and generates a second summing signal 567b. The second summing signal 567b is inverted by a second inversion circuit 570b. The second summing signal 567b and the inverted second summing signal 572b are received by a two-input multiplexer 575b.

The first intermediate output signal 551 is used as a selection signal for both the multiplexer 575a and the multiplexer 575b. The multiplexer 575a then generates a first selected signal 578a, the first selected signal 578a and the input signal x_i are received by a third summing circuit 580a to generate a first iteration signal 585a that includes x_i+1. The multiplexer 575b generates a second selected signal 578b, the second selected signal 578b and the input signal y_l are received by a fourth summing circuit 580b to generate a second iteration signal 585b that includes y_i+1. The unit cell 520i also includes a third inversion circuit 570c receives and inverts a first angle signal that includes ϕ_i. The first angle signal ϕ_i and the first inverted angle signal 572c are received by a third multiplexer 575c. The first intermediate output signal 551 is also used as a selection signal for the multiplexer 575c. The multiplexer 575c generates a third selected signal 578c, the third selected signal 578c and first angle signal ϕ_i are received by a fifth summing circuit 580c to generate a third iteration signal 585c that includes z_i+1.

FIG. 5C depicts an exemplary unit cell implemented in vectoring mode. When θ_i=0, an exemplary unit cell 520i′ implemented in the second pipeline-CORDIC includes the first buffer 550a configured to receive x_i, the second buffer 550b configured to receive y_i, and the third buffer 550c configured to receive z_i. The second buffer 550b is configured to output the first intermediate output signal 551 and the second intermediate output signal 552. The first intermediate output signal 551 includes the MSB of input y_i to identify the sign of the input y_i, and the second intermediate output signal 552 includes the whole input y_i.

The unit cell 520i also includes the second shifter 555b coupled to the output of the first buffer 550a. The second shifter 555b may right shift the input x_i (i−∈(i)) bits and then generates the second shifted signal 560b. The unit cell 520i also includes the fourth shifter 555d coupled to the output of the second buffer 550b to receive the second intermediate output signal 552 includes the whole input y_i. The fourth shifter 555d may right shift the input y_i (i−∈(i)) bits and then generates the fourth shifted signal 560d.

The fourth shifted signal 560d is inverted by a first inversion circuit 570a (e.g., an inverter). The fourth shifted signal 560d and the inverted fourth shifted signal 573a are received by the multiplexer 575a. The second shifted signal 560b is inverted by the second inversion circuit 570b. The second shifted signal 560b and the inverted second shifted signal 573b are received by the multiplexer 575b.

The first intermediate output signal 551 is used as a selection signal for both the multiplexer 575a and the multiplexer 575b. The multiplexer 575a then generates a first selected signal 579a, the first selected signal 579a and the input signal x_i are received by the third summing circuit 580a to generate a first iteration signal 590a that includes x_i+1. The multiplexer 575b generates a second selected signal 579b, the second selected signal 579b and the input signal y_i are received by the fourth summing circuit 580b to generate a second iteration signal 590b that includes y_i+1. The unit cell 520i also includes the third inversion circuit 570c receives and inverts a first angle signal that includes ϕ_i. The first angle signal ϕ_i and the first inverted angle signal 572c are received by the third multiplexer 575c. The first intermediate output signal 551 is also used as a selection signal for the multiplexer 575c. The multiplexer 575c generates a third selected signal 578c, the third selected signal 578c and first angle signal ϕ_i are received by the fifth summing circuit 580c to generate a third iteration signal 590c that includes z_i+1. In some embodiments, as hardware resources used in the first pipelined-architecture 415 are similar to the hardware resources used in the second pipelined-architecture 515, a hybrid architecture may be designed to work in a rotation mode or a vectoring mode by a control signal. For example, a multiplexer may be used to receive both the sign signal 451 of input Zi and sign signal of input yi, and the control signal may select between the two sign signals 451 and 551 to control working mode of the hybrid architecture.

FIG. 6 depicts a second exemplary rotation mode engine of the modified CORDIC engine. The RME2 250 is configured to receive the second data set 215 (having V_pi and k_i) and the fourth data set 425 (having

$2f_{ln}\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}\right)$ and k_i).

In this depicted example, the RME2 250 includes a second subtracting circuit 602 configured to subtract exponent k_total (included in the third-sub2 data set 225b) from k_i (included in the second-sub2 data set 215b) and generate a second subtracting signal 604 (that includes k_i−k_total). The RME2 250 also includes an eighth summing circuit 608 configured to receive the second-sub1 data set 215a that includes V_pi and the fourth-sub1 data set 235a that includes

$2f_{ln}\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}\right)$ to generate a second summing signal 609. The second summing signal 609 (includes

$V_{pi}+2f_{ln}\left(\frac{\sum _{j=1}^n{2}^{k_j}·f_{exp}\left(V_{pj}\right)}{2^{k_{\mathrm{total}}}}\right)$ is then casted from C_it+2 bits into C_it+Z bits in a casting circuit 610. A third pipeline-CORDIC architecture 615 coupled to the output of the casting circuit 610. The third pipeline-CORDIC architecture 615 is configured by cascade-connecting C_it stages of unit cells 620₁-620_Cit. Each stage of unit cell may be configured to work in rotation mode. Each unit cell 620₁-620_Cit includes four inputs X_in, Y_in, Z_in, ϕ_i, and three outputs X_out, Y_out, Z_out. The four inputs X_in, Y_in, Z_in, and ϕ_i are configured to receive input data (e.g., incoming values X_i, Y_i, Z_i, and a corresponding angle ϕ₁˜ϕ_cit, respectively). The incoming values received by the first unit cell 620₁ are 1, 1, the second summing signal 609, and ϕ₁. In some embodiments, the third pipeline-CORDIC architecture 615 may have the same architecture with the first pipeline-CORDIC architecture 415 as shown in FIGS. 4A-4C.

The RME2 250 also includes a second delay path 625 configured to receive the second subtracting signal 604 (that includes k_i−k_total). The second delay path 625 may include one or more delay units connected in series to introduce a delay equal to the delay caused by the third pipeline-CORDIC architecture 615. The RME2 250 also includes a second state machine 630. The second state machine 630 is configured to the output of the third pipeline-CORDIC architecture 615 to receive a twelfth signal 623 that includes

$f_{exp}(V_{pi}+2f_{ln}\left(\frac{\sum _{j=1}^n{2}^{k_i}·f_{exp}\left(V_{pi}\right)}{2^{k_{\mathrm{total}}}}\right)$ and the output of the delay path 625 to receive a thirteenth signal 627 that includes a delayed second subtracting signal. The second state machine 630 is configured to perform operations to generate the output data set 255 in response to the received twelfth signal 623 and the received thirteenth signal 627. For example, when

$f_{exp}(V_{pi}+2f_{ln}\left(\frac{\sum _{j=1}^n{2}^{k_i}·f_{\exp }\left(V_{pi}\right)}{2^{k_{\mathrm{total}}}}\right)>1,$ then a shift to the right of up to two positions may be performed, with an increase in the corresponding k_i value. Thus, SoftMax calculation may be easily performed by the modified CORDIC engine 200.

FIG. 7A depicts a block diagram of an exemplary configuration system having a development environment and an implementation environment to implement the modified CORDIC engine in a field programmable gate array (FPGA) device. A configuration system 700 includes a development environment 705. The development environment 705 may be a software suite (such as the Vivado® Suite distributed by Xilinx, Inc) including a number of tools for performing EDA design. A user may, via a user interface, use a high-level language to generate, at design time, instructions that can produce, via register transfer logic (RTL) generation at compile time, a modified CORDIC engine (e.g., the modified CORDIC engine 200) that, at run-time, can efficiently perform SoftMax calculation. The environment 705 includes a, for example, high-level language program 710, such as HDL code, that is used for designing hardware systems. The program 710 may be compiled by a high-level language compiler 715. The HLL compiler 715 operatively connects with the HLL program 710 and a database 720. In this depicted example, the database 720 includes user libraries 720a and HLL libraries 720b. For example, the user libraries 720a may include different multiplexers, inversion circuits, and delay circuits. The HLL compiler 715 may select available library files in the database 720 to compile HLL commands into one or more sets of instructions, which may also be referred to as data structures.

The environment 705 may be running on a processor 723 operably coupled to non-volatile memory (NVM) 725. NVM 725 contains instructions, that when executed by the processor 723, cause the processor 723 to perform operations that enable the various tools and functionality of the environment 705. For example, the NVM 725 may include design-time executable instructions that perform various operations involving EDA design. NVM 725 also may include design-time executable instructions that include various programs, routines, and/or operations that are executed during design time for a target device (e.g., when the target device is being configured/set up).

The configuration system 700 includes an implementation environment 730. In some examples, the implementation environment 730 may be packaged with the development environment 705. The implementation environment 730 includes various tools 730a for hardware and/or software simulation, synthesis/regeneration, and/or implementation (e.g., place and route). An implementation engineer, for example, may employ some compiler tools to convert the instructions stored in the NVM 725 into hardware/software implementations 730a that can be loaded via a bitstream, for example, into a target device such as an FPGA. In some embodiments, the implementation environment 730 may generate the appropriate data files to realize fixed hardware (e.g., in an ASIC) in accordance with the design specified by, for example, the user-input high-level language programming in the development environment 705.

A target device 735 may, for example, be a system on a chip (SOC) that includes various components, at least one among them being a field programmable gate array (FPGA) 740. The FPGA 740 may be programmed/configured “on-the-fly” to the modified CORDIC engine 200 by taking a bitstream of the implementation generated by environments 705 and 730 and writing the bitstream into programmable logic (PL) of the FPGA 740.

The target device 735 includes a number of buffers 745a (e.g., which may form an I/O interface) that connect external signals into the FPGA 740. The FPGA 740 may include n programmable logic blocks that represent programmable hardware resources available to realize circuitry in accordance with the design specified by, for example, the user-input high-level language programming in the development environment 705. The FPGA 740 also connects with other devices 745b, which may provide a variety of auxiliary functions. Exemplary process flow steps that may be performed at design time are described in further detail, for example, with reference to FIG. 8A. Thus, by using the modified CORDIC method that mainly based on shifts and adds, and without the need of any multipliers, SoftMax calculations may be easily performed. Accordingly, the implementation of SoftMax calculations may advantageously reduce the cost of silicon area and/or the instructions performed by a processing engine.

In some embodiments, part or all functions of the modified CORD IC engine 200 may be implemented in the processor 723. A data storage device (e.g., NVM 725) may be coupled to the processor 723 and containing a program of instructions that, when executed by the processor 723, cause the processor 723 to perform operations to conduct SoftMax calculation. The operations may include (a) retrieving an input vector V representative of an input data set, (b) transforming each element V_i of the input vector V into another expression shown in equation 30 to generate a second data set (e.g., the second data set 215), (c) determining (e.g., by the processor 723) whether each and every element V_i in the input vector V has been transformed. If all elements have been transformed, the operations may also include (d) performing exponential calculations on the second data set 215 to generate a third data set 225 comprising a third-sub1 data set 225a and a third-sub2 data set 225b, and (e) performing logarithm calculations to generate a fourth-sub1 data set 235a and storing the fourth-sub1 data set 235a in the floating point register 230. The operations may also include (f) performing exponential calculations to generate an output data set (e.g., the output data set 255). Thus, SoftMax calculations may be easily performed by using the modified CORDIC method that mainly based on shifts and adds, and without the need of any multipliers.

An example to implement the modified-CORDIC method in software is discussed. The following pseudo code explains an exemplary way to calculate the exponential function using the modified-CORDIC method. According to the number of iterations used (cordic_iter or C_it shown in FIG. 4A), and the input range of values for which the exponential function is evaluated, sequences f(i), ϕ_i, and ϕ_i may be defined. In a modified-CORDIC implementation, there are values of i for which

$f\left(i\right)=2^{-\left(i-{\Sigma }_{j=1}^{i-1}j\right)},$ and there are also values of i for which

$f\left(i\right)=2^{-\left(i-{\Sigma }_{j=1}^{i-1}j\right)}+2^{-\left(i+1-{\Sigma }_{j=1}^{i-1}j\right)},$ which may be determined by the values of sequence θ_i. When θ_i=0,

$f\left(i\right)=2^{-\left(i-{\Sigma }_{j=1}^{i-1}j\right)},$ and when θ_i=1,

$f\left(i\right)=2^{-\left(i-{\Sigma }_{j=1}^{i-1}j\right)}+2^{-\left(i+1-{\Sigma }_{j=1}^{i-1}j\right)}.$

${\theta }_i\in \left\{0,1\right\}$ $ϵ\left(i\right)=\sum _{j=1}^{i-1}{\theta }_j$ $f\left(i\right)=\{\begin{array}{c}{2}^{-\left(i-ϵ\left(i\right)\right)},\mathrm{if}{\theta }_i=0\\ 2^{-\left(i-ϵ\left(i\right)\right)}+2^{-\left(i+1-ϵ\left(i\right)\right)},\mathrm{if}{\theta }_i=1\end{array}{\varphi }_i=\mathrm{atanh}\left(f\left(i\right)\right){\exp }_{\mathrm{range}}=\sum _{i=1}^{+\infty }{\varphi }_i{A}_n=\prod _{i=1}^n\cosh {\varphi }_i$ Exemplary algorithm ALGORITHM-1 to perform exponential calculations may be:

1:  Procedure EXP_CORDIC
2:  cordic_iter ← number of cordic iterations
3:  xystate ← 1
4:  in_value ← exponential input value ϵ (−exprange, exprange)
5:  zstate ← in_value
6:  i ← 1
7:  loop:
8:  while i ≤ cordic_iter do
9:  if zstate < 0 then
10: if θi == 0 then
11: xystate ← xystate −(xystate >> i − ϵ(i))
12: else
13: xystate ← xystate − (xystate >> i − ϵ(i)) − (xystate >> i + 1 − ϵ(i))
14: zstate ← zstate +ϕi
15: else
16: if θi == 0 then
17: xystate ← xystate +(xystate >> i − ϵ(i))
18: else
19: xystate ← xystate + (xystate >> i − ϵ(i)) + (xystate >> i + 1 − ϵ(i))
20: zstate ← zstate −ϕi
21: i = i + 1

The final value of variable xy_state variable in the ALGORITHM-1 may be proportional to desired exponential, with a value of A_n⁻¹·e^−in_value. The following pseudo code explains an exemplary way to calculate the logarithm function using the modified-CORDIC method. In some embodiments, sequences f(i), ϕ_i, and θ_i used in the exponential and the logarithm CORDIC-based calculations may be kept the same. According to the choice of ϕ_i, a new input range may be defined for the logarithm implementation. In this example,

${\ln }_{\mathrm{range}}=e^{2·{\Sigma }_{i=1}^{+\infty }{\varphi }_i},$ and the input range of values for the logarithm calculation may be ∈(ln_range⁻¹, ln_range). Exemplary algorithm ALGORITHM-2 to perform logarithm calculations may be:

1:  Procedure LN_CORDIC
2:  cordic_iter ← number of cordic iterations
3:  in_value ← logarithm input value ϵ (lnrange−1, lnrange)
4:  xstate ← in_value +1
5:  ystate ← in_value −1
6:  zstate ← 0
7:  i ← 1
8:  loop:
9:  while i ≤ cordic_iter do
10: if ystate > 0 then
11: if θi == 0 then
12: xstate ← xstate −(ystate >> i − ϵ(i))
13: ystate ← ystate −(xstate >> i − ϵ(i))
14: else
15: xstate ← xstate − (ystate >> i − ϵ(i)) − (ystate >> i + 1 − ϵ(i))
16: ystate ← ystate − (xstate >> i − ϵ(i)) − (xstate >> i + 1 − ϵ(i))
17: zstate ← zstate +ϕi
18: else
19: if θi == 0 then
20: xstate ← xstate +(ystate >> i − ϵ(i))
21: ystate ← ystate +(xstate >> i − ϵ(i))
22: else
23: xstate ← xstate + (ystate >> i − ϵ(i)) + (ystate >> i + 1 − ϵ(i))
24: ystate ← ystate + (xstate >> i − ϵ(i)) + (xstate >> i + 1 − ϵ(i))
25: zstate ← zstate −ϕi
26: i = i + 1

The final value of the variable z_state in the ALGORITHM-2 may be proportional to a desired logarithm, with a value of ½ ln (in_value). The following pseudocode depicts a way that SoftMax is calculated over in input vector {right arrow over (V)}=(V(1), V(2), . . . , V(n)), using the exponential and logarithm calculations based on the modified-CORDIC method. In this depicted example, each number V(i) may not be a very large number, and input transformation steps may be achieved by performing an iterative subtraction instead of dividing. Exemplary algorithm ALGORITHM-3 to perform input transformation may be:

1:  Procedure SOFTMAX_CORDIC
2:  {right arrow over (V)} ← input vector of values V(1) to V(n)
3:  1. Input transformation: Each value in the input vector {right arrow over (x)} is transformed into two values
VP(i) and kP(i), so that V(i) = VP(i) + kP(i) · ln2.
4:  {right arrow over (kP)}← {right arrow over (0)}
5:  {right arrow over (VP)}← {right arrow over (0)}
6:  for (i = 1; i ≤ n;i + + ) do
7:  if V(i) < 0 then
8:  aux← −V(i)
9:  else
10: aux← V(i)
11: while aux − ln2 >0 do
12: aux ← aux - ln2
13: kP(i) ← kP(i) + 1
14: VP(i) ← aux
15: if V(i) < 0 then
16: kP(i) ← − kP(i)
17: VP(i) ← −V(i)
18: 2. Calculate Normalizing Factor: For each −1<VP(i)<1, a condition may need to meet is
exp                              range                                                        =                                                                                                                            ∑                                                                      i                                    =                                    1                                                                                                        +                                    ∞                                                                                                  ⁢                                                                  ϕ                                  i                                                                                            ≥                              1.                                                                                ⁢                                                                                                          ⁢                                                      This                            ⁢                                                                                                                  ⁢                            step                            ⁢                                                                                                                  ⁢                            may                            ⁢                                                                                                                  ⁢                            generate                            ⁢                                                                                                                  ⁢                            the                            ⁢                                                                                                                  ⁢                            dominator                            ⁢                                                                                                                  ⁢                            of                            ⁢                                                                                                                  ⁢                            the                            ⁢                                                                                                                  ⁢                            Softmax                            ⁢                                                                                                                  ⁢                            expression                                                    ,                                                                                                          ⁢                                                      which                            ⁢                                                                                                                  ⁢                            is                            ⁢                                                                                                                  ⁢                                                                                          ∑                                                                  i                                  =                                  1                                                                                                  +                                  ∞                                                                                            ⁢                                                                                                                                    2                                                                                                                  k                                        P                                                                            ⁡                                                                              (                                        i                                        )                                                                                                                                              ·                                  exp                                                                ⁢                                                                                                                                  ⁢                                                                                                      CORDIC                                    ⁡                                                                          (                                                                                                                        V                                          P                                                                                ⁡                                                                                  (                                          i                                          )                                                                                                                    )                                                                                                        .
    This normalizing value will be then scaled by An.
19: norm← 0
20: for (i = 1; i ≤ n; i + + ) do
21: norm ← norm +( expCORDIC (VP(i)) >>kP(i))
22: 3. Calculate the logarithm: The normalizing constant may be expressed in its floating
point representation norm=normmant · 2normexp . The logarithm is applied to the variable norm,
and ln(norm)=ln(normmant · 2normexp)=ln(normmant)+ ln(2normexp )= ln(2normexp )+ 2.
lnCORDIC(normmant). In this example, mantissa may be a number between 0.10... and 0.11...,
meaning that it will be ∈ [0.5, 1), making the input range of the lnCORDIC(normmant) function
work with the condition∑i=1+∞⁢ϕi≥1.
23: level 1 ← −2· lnCORDIC(normmant)
24: level 2 ← -normexp
25: 4. Calculate the second exponential: the input will be VP(i) + lnval1. The
variable val1 may achieve a maximum value of ln(2), and the input range of the exponential
function expCORDIC may go up to I +ln(2), and the new condition for ϕi may become
    ∑                                                              i                                =                                1                                                                                            +                                ∞                                                                                      ⁢                                                          ϕ                              i                                                                                ≥                                                      1                            +                                                                                          ln                                ⁡                                                                  (                                  2                                  )                                                                                            .                                                                                                                                                                                                                                                                                              The values in the variables xSF will be the output of SoftMax.
26: {right arrow over (VSF)}← {right arrow over (0)}
27: for (i = 1; i ≤ n;i + + ) do
28: VP(i) ← expCORDIC (VP(i) + lnval1)
29: kP(i) ← kP(i) + lnval2
30: VSF(i) ← (VP(i) << kP(i))

The following exemplary sequences are defined for a number of CORDIC iterations equal to, for example, 12. Other sequences may be used as long as the previously mentioned three conditions are satisfied.

$\overrightarrow{\theta }=\left[0,1,0,1,0,0,1,0,0,1,0,1\right]$ $\overrightarrow{f}=\left[\frac{1}{2},\frac{1}{4}+\frac{1}{8},\frac{1}{4},\frac{1}{8}+\frac{1}{16},\frac{1}{8},\frac{1}{16},\frac{1}{32}+\frac{1}{64},\frac{1}{32},\frac{1}{64},\frac{1}{128}+\frac{1}{256},\frac{1}{128},\frac{1}{256}+\frac{1}{512}\right]$ $\overrightarrow{\varphi }=\left[0.5493,0.3942,0.2552,0.1897,0.1257,0.0626\dots ,0.0469,0.0313.0.0156,0.0117,0.0078,0.0059\right]$ $\overrightarrow{ϵ}=\left[0,0,1,1,2,2,2,3,3,3,4,4\right]$ $\overrightarrow{V}=\left(-3.73,4.13,1.32,-4.02,2.21,0.46,4.57,2.64,-3.42,3.00\right)$

The method to calculate SoftMax is explained step by step. In the first step, input vectors are transformed. By iteratively subtracting ln(2), the new format of vectors are obtained. For example, V_p(1)+k_p(1)ln(2)=−0.2643−5*ln2=−3.72=V(1). {right arrow over (V_p)}=[−0.2643, 0.6643, 0.6269, −0.5543, 0.1306, 0.4600, 0.4111, 0.5606, −0.6474, 0.2274], {right arrow over (k_p)}=[−5, 5, 1, −5, 3, 0, 6, 3, −4, 4].

Then, a first exponential function is used to calculate the normalizing factor. The exponential calculation will be shown for the first element of {right arrow over (V_p )} and {right arrow over (k_p)}. The z_state is set to V_p(1)=−0.2643.

• 1: z_state≥0, θ(i)=0, iter=1,
  • xy_state=xy_state+(xy_state>>iter+ϵ(j))=1−(1>>1+0)=1.5
  • z_state=Z_state−ϕ(j)=0.22741−0.54931=−0.32189
• 2: z_state<0,θ(i)=1, iter=2,
  • xy_state=xy_state−(xy_state>>iter−ϵ(j))−(xy_state>>iter+1−ϵ(j))
  • =1.5−(1.5>>2−0)−(1.5>>2+1−0)=0.9375
  • z_state=z_state+ϕ(j)=−0.32189+0.39423=0.072334
• 3: z_state≥0, θ(i)=0, iter=3,
  • xy_state=xy_state+(xy_state>>iter−ϵ(j))=0.9375−(0.9375>>3+1)=1.1719
  • z_state=z_state−ϕ(j)=0.072334−0.25541=−0.18308
• 4: z_state<0, θ(i)=1, iter=4,
  • xy_state=xy_state−(xy_state>>iter−ϵ(j))−(xy_state>>iter+1−ϵ(j))
  • =1.1719−(1.1719>>4−1)−(1.1719>>4+1−1)=0.95215
  • z_state=z_state+ϕ(j)=−0.18308+0.18974=0.0066658
• 5: z_state≥0, θ(i)=0, iter=5,
  • xy_state=xy_state+(xy_state>>iter−ϵ(j))=0.95215>>5+2)=1.0712
  • z_state=z_state−ϕ(j)=0.0066658−0.12566=−0.11899
• 6: z_state<0, θ(i)=0, iter=6,
  • xy_state=xy_state−(xy_state>>iter−ϵ(j))=1.0712−(1.0712>>6−2)=1. 0042
  • z_state=z_state+ϕ(j)=−0.11899+0.0.6582=−0.05641
• 7: z_state<0, θ(i)=1, iter=7,
  • xy_state=xy_state−(xy_state>>iter−ϵ(j))−(xy_state>>iter+1−ϵ(j))
  • =1.0042−(1.0042>>7−2)−(1.0042>>7+1−2)=0.95715
  • z_state=z_state+ϕ(j)=−0.05641+0.046909=−0.0095005
• 8: z_state<0, ϕ(i)=0, iter=8,
  • xy_state=xy_state−(xy_state>>iter−ϵ(j))=0.95715−(0.95715>>8−3)=0.92724
  • z_state=z_state+ϕ(j)=−0.0095005+0.03126=0.02176
• 9: z_state≥0, θ(i)=0, iter=9,
  • xy_state=xy_state+(xy_state>>iter−ϵ(j))=0.92724−(0.92724>>9+3)=0.94172
  • z_state=z_state−ϕ(j)=0.02176−0.015626=0.0061335
• 10: z_state≥0, θ(i)=0, iter=10,
  • xy_state=xy_state+(xy_state>>iter−ϵ(j ))+(xy_state>>iter+1−ϵ(j))=0.94172+(0.94172>>10−1−3)=0.95276
  • z_state=z_state−ϕ(j)=0.0061335−0.011719=−0.0055858
• 11: z_state<0, θ(i)=0, iter=11,
  • xy_state=xy_state−(xy_state>>iter−ϵ(j))=0.95276−(0.95276>>11−4)=0.94532
  • z_state=z_state+ϕ(j)=−0.0055858+0.0078127=0.0022268
• 12: z_state≥0, θ(i)=0, iter=12,
  • xy_state=xy_state+(xy_state>>iter−ϵ(j))+(xy_state>>iter+1−ϵ(j))=0.94532+(0.94532>>12−4)+(0.94532>>12+1−4)=0.95085
  • z_state=z_state−ϕ(j)=0.0022268−0.0058594=−0.0036326

In the last iteration, xy_state=0.58057, which, if multiplied by An=1.3250, is very close to the value e^−0.2643. The output of the exponential calculation with CORDIC is: expCORDIC ({right arrow over (V_p)})=[0.58057, 1.4677, 1.4059, 0.4347, 0.86031, 1.1965, 1.1417, 1.3257, 0.39573, 0.39573]. The resulting normalizing value when adding up all the elements of expCORDIC({right arrow over (V_P)}) is 156.7983, for which norm_exp=8, and norm_mant=0.61249.

Then, the logarithm is calculated:

• 1: y_state≥0, θ(i)=0, iter=1,
  • x_state=x_state+(y_state>>iter−ϵ(j))=1.6125+(−0.38751>>1−0)=1.4187,
  • y_state=y_state+(x_state>>iter−ϵ(j))=−0.38751+(1.6125 >>1−0)=0.41874
  • z_state=z_state−ϕ(j)=0−0.54931=−0.54931
• 2: y_state>0, θ

(i)=1, iter=2,

• • x_state=x_state−(y_state>>iter−ϵ(j))−(y_state>>iter+1−ϵ(j))=1.4187+(0.32186>>2−0)−(0.32186>>2+1−0)=1.298,
  • y_state=y_state−(x_state>>iter−ϵ(j))−(x_state>>iter +1−ϵ(j))=0.32186+(1.4187>>2−0)−(1.4187>>2+1−0)=−0.21016
  • z_state=z_state+ϕ(j)=−0.54931+0.39423=−0.15508
• 3: y_state≤0, θ(i)=0, iter=3,
  • x_state=x_state+(y_state>>iter−ϵ(j))=1.298+(−0.1649>>3−1)=1.2568,
  • y_state=y_state+(x_state>>iter−ϵ(j)=−0.1649+(1.298>>3−1)=0.15961
  • z_state=z_state−ϕ(j)=0.15508−0.25541=−0.41049
• 4: y_state>0, θ(i)=1, iter=4,
  • x_state=x_state−(y_state>>iter−ϵ(j))−(y_state>>iter+1−ϵ(j))=1.2568−(0.1493>>4−1)−(0.1493>>4+1−1)=1.2288,
  • y_state=y_state−(x_state>>iter−ϵ(j))−(x_state>>iter +1−ϵ(j))=0.1493+(1.2568>>4−1)−(0.1493>>4+1−1)=−0.086351
  • z_state=z_state+ϕ(j)=−0.41049+0.18974=−0.22075
• 5: y_state≤0, θ(i)=0, iter=5,
  • x_state=x_state+(y_state>>iter−ϵ(j))=1.2288+(−0.081102>>5−2)=1.2187,
  • y_state=y_state+(x_state>>iter−ϵ(j))=−0.081102+(1.2288>>5−2)=0.072501
  • z_state=z_state−ϕ(j)=0.22075−0.12566=−0.3464
• 6: y_state<0, θ(i)=0, iter=6,
  • x_state=x_state−(y_state>>iter−ϵ(j))=1.2187−(−0.071233>>6−2)=1.2142,
  • y_state=y_state−(x_state>>iter−ϵ(j))=−0.071233+(1.2187>>6−2)=−0.0049343
  • z_state=z_state+ϕ(j)=−0.3464+0.062582=−0.28382
• 7: y_state≤0, θ(i)=1, iter=7,
  • x_state=x_state−(y_state>>iter−ϵ(j))+(y_state>>iter+1−ϵ(j))=1.2142+(−0.004656>>7−2)+(−0.004656>>7+1−2)=1.214,
  • y_state=y_state+(x_state>>iter−ϵ(j))+(x_state>>iter+1−ϵ(j))=−0.004656+(1.2142>>7−2)+(1.2142>>7+1−2)=0.052261
  • z_state=z_state+ϕ(j)=−0.28382−0.046909=−0.33073
• 8: y_state<0, θ(i)=0, iter=8,
  • x_state=x_state−(y_state>>iter−ϵ(j))=1.214−(0.052251>>8−3)=1.21242,
  • y_state=y_state−(x_state>>iter−ϵ(j))=0.52251+(1.214>>8−3)=0.014313
  • z_state=z_state+ϕ(j)=−0.33073+0.03126=−0.29947
• 9: y_state<0, θ(i)=0, iter=9,
  • x_state=x_state−(y_state>>iter−ϵ(j))=1.2124−(0.014364>>9−3)=1.2122,
  • y_state=y_state−(x_state>>iter−ϵ(j))=0.014364+(1.2124>>9−3)=−0.0045795
  • z_state=z_state+ϕ(j)=−0.29947+0.015626=−0.28384
• 10: y_state≤0, θ(i)=1, iter=10,
  • x_state=x_state−(y_state>>iter−ϵ(j))+(y_state>>iter+1−ϵ(j))=1.2122+(−0.004576>>10−3)+(−0.004576>>10+1−3)=1.2121,
  • y_state=y_state+(x_state>>iter−ϵ(j))+(x_state>>iter+1−ϵ(j))=−0.004576+(1.2122>>10−3)+(1.2122>>10+1−3)=0.009629
  • z_state=z_state+ϕ(j)=−0.28384−0.011719=−0.29556
• 11: y_state<0, θ(i)=0, iter=11,
  • x_state=x_state−(y_state>>iter−ϵ(j))=1.2121−(0.096283>>11−4)=1.212,
  • y_state=y_state−(x_state>>iter−ϵ(j))=0.096283+(1.2121>>11−4)=0.00015878
  • z_state=z_state+ϕ(j)=−0.29556+0.0078127=−0.28775
• 12: y_state<0, θ(i)=0, iter=12,
  • x_state=x_state−(y_state>>iter−ϵ(j))−(y_state>>iter+1−ϵ(j))=1.212−(0.00015937>>12−4)−(0.00015937>>12+1−4)=1.212,
  • y_state=y_state−(x_state>>iter−ϵ(j))−(x_state>>iter+1−ϵ(j))=−0.00015937−(1.212>>12−4)−(1.212>>12+1−4)=0.0069424
  • z_state=z_state+ϕ(j)=−0.28775+0.00585949=−0.28189

The two values of interest at this step are lnval1=−2 norm_mant=−2*(−0.28189)=0.56378, and lnval2=−norm_exp=−8. Then, the second exponential calculation is briefly discussed. First, lnval1=0.56378 is added to all the elements of {right arrow over (V_p)}, resulting in [0.2995, 1.2280, 1.1906, 0.0095, 1.0238, 0.9749, 1.1243, −0.0836, 0.7912]. Then, the exponential of the modified elements of {right arrow over (V_p)} are calculated using the expCORDIC approach, resulting in [1.0202, 2.5915, 2.4749, 0.7613, 1.5189, 2.1001, 2.0096, 2.3248, 0.6973, 1.6684]. The value lnval2=−norm_exp=−8 is then added to all of the elements of {right arrow over (k_p)}, resulting in [−13, −3, −7, −13, −5, −8, −2, −5, −12, −4]. Finally, every element of the expCORDIC approach is shifted to the right by the amount shown in the following corresponding value [0.0001, 0.3239, 0.0193, 0.0001, 0.0475, 0.0082, 0.5024, 0.0726, 0.0002, 0.1043], resulting in the final SoftMax output, the SoftMax function may be calculated with an accuracy set by the number of CORDIC iterations. Thus, the types of operations executed by the processing engine to accurately perform a very complicated function are simple (e.g., add, subtract, shifts), no multiplications or divisions are needed.

An example to implement the modified-CORDIC method in hardware is also discussed. First, the calculation of the exponential function is shown. The restrictions mentioned in equation 26 are applied to the input value, which is that a value

$\in \left(-\sum _{i=k}^{+\infty }{\varphi }_i,\sum _{i=k}^{+\infty }{\varphi }_i\right).$ The same parameters mentioned in the software implementation may be used here. In this depicted example, the values in vector {right arrow over (ϕ)} have been scaled and rounded so that the vector may be represented in 12 bits.{right arrow over (θ)}=[0,1,0,1,0,0,1,0,0,1,0,1]{right arrow over (ϕ)}=[2250,1615,1046,777,515,256,192,128,64,48,32,24]{right arrow over (∈)}=[0,0,1,1,2,2,2,3,3,3,4,4]

A first pipelined architecture (e.g., the RME1 220) may be used for the calculation of the exponential function using N number of steps in rotation mode. According to the value of 0, different unit cells with different shifters may be used. In some embodiments, the first pipelined architecture may be further optimized to utilize each of the stage multiple times, limiting the pipelined throughput capability, but reducing the amount of hardware resources used. In this depicted example, 12 bits is chosen to be the number of bits representing the {right arrow over (ϕ)}, which is the total number of pipelined stages in the first pipelined architecture and the resolution of the input values. When an input value 3710 (Zin) is applied to the RME1 220, which represents the value 0.9058, the calculation happened in each stage of the first piped architecture is discussed for the chosen input value. The values of X and Y will change in every iteration, and in this depicted example, X will always be equal to Y in the calculation of the exponential using rotation mode. Thus, in the following example, X and Y have been collapsed into XY.

1: stage i=1, θ₁=0, xy₁=4096, z₁=3710

First Shift to the right, with i−ϵ(i)=1, xy₁>>1=2048

Because z₁>0, xy₂⇐xy₁+2048=6144, z₂⇐z₁−ϕ₁=3710−2249=1461

2: stage i=2, θ₂=1, xy₂=6144, z₂=1461

First Shift to the right, with i−ϵ(i)+1=3 and i−ϵ(i)=2, xy₂>>3+xy₂>>2=2304

Because z₂>0, xy₃⇐xy₂+2304=8448, z₃⇐z₂−ϕ₂=1461−1614=−153

3: stage i=3, θ₃=0, xy₃=8448, z₃=−153

First Shift to the right, with i−ϵ(i)+2, xy₃>>2=2112

Because z₃>0, xy₄⇐xy₃−2122=6336, z₄⇐z₃+ϕ₃=−153+1046=893

4: stage i=4, θ₄=0, xy₄=6336, z₄=893

First Shift to the right, with i−ϵ(i)+1=4, i−ϵ(i)=3, xy₄>>4+xy₄>>3=1188

Because z₄>0, xy₅⇐xy₄+1188=7524, z₅⇐z₄−ϕ₄=893−777=116

5: stage i=5, θ₅=0, xy₅=4096, z₅=3710

First Shift to the right, with i−ϵ(i)=3, xy₅>>3=940

Because z₅>0, xy₆⇐xy₅+940=8464, z₆⇐z₅−ϕ₅=116−514=−398

6: stage i=6, θ₆=0, xy₆=8464, z₆=−398

First Shift to the right, with i−ϵ(i)=4, xy₆>>4=529

Because z₆<0, xy₇⇐xy₆−529=7935, z₇⇐z₆+ϕ₆=−398+256=−142

7: stage i=7, θ₇=0, xy₇=7935, z₇=−142

First Shift to the right, with i−ϵ(i)+1=6 and i−ϵ(i)=5, xy₇>>6+xy₇=370

Because z₇<0, xy₈⇐xy₇−370=7565, z₈⇐z₇+ϕ₇=−142+192=5−

8: stage i=8, θ₈=0, xy₈=7565, z₈=50

First Shift to the right, with i−ϵ(i)=5, xy₈>>5=236

Because z₈>0, xy₉⇐xy₈+236=7801, z₉⇐z₈−ϕ₈=50−128=−78

9: stage i=9, θ₉=0, xy₉=7801, z₉=−78

First Shift to the right, with i−ϵ(i)=6, xy₉>>6=121

Because z₉<0, xy₁₀⇐xy₉−121=7680, z₁₀⇐z₉+ϕ₉=−78+64=−14

10: stage i=10, θ₁₀=1, xy₁₀=7680, z₁₀=−14

First Shift to the right, with i−ϵ(i)+1=8 and i−ϵ(i)=7, xy₁₀>>8+xy₁₀>>7=90

Because z₁₀<0, xy₁₁⇐xy₁₀−90=7590, z₁₁⇐z₁₀+ϕ₁₀=−14+48=34

11: stage i=11, θ₁₁=0, xy₁₁=7590, z₁₁=34

First Shift to the right, with i−ϵ(i)=7, xy₁₁>>7=59

Because z₁₁>0, xy₁₂⇐xy₁₁+59=7649, z₁₂⇐z₁₁−ϕ₁₁=34−32=2

12: stage i=12, θ₁₂=0, xy₁₂=7649, z₁₂=2

First Shift to the right, with i−ϵ(i)+1=9 and i−ϵ(i)=8, xy₁₂>>9+xy₁₂>>8=43

Because z₁₂>0, xy₁₃⇐xy₁₂+43=7692, z₁₃⇐z₁₂−ϕ₁₂=2−24=−22

The final output value of the first pipelined architecture is 7692, which represents 1.8779, and if it is multiplied by An=1.3250, the value obtained is 2.4483≈e^0.9058. A second pipelined architecture (e.g., the VME 240) is implemented in the calculation of the natural logarithm. The constraints on the input values are shown in equation 27, which dictates that the input value is

$\in \left(e^{2·\sum _{i=k}^{+\infty }{\varphi }_i},e^{2·\sum _{i=k}^{+\infty }{\varphi }_i}\right).$

According to the value of 0, different unit cells may be used. In this depicted example, the same number of iterations is used, with the input represented with 12 bits. When an input value 0.8003 is applied to the second pipelined architecture, which represents the value 3278 in 12 bits, the calculation happened in each stage of the second piped architecture is discussed for the chosen input value. x₁=7374, y₁=−818.

1: stage i=1, θ₁=0, x₁=7374, y₁=−818, z₁=0

First Shift to the right, with i−ϵ(i)=1, x₁>>1=3678, y₁>>1=−409

Because y₁<0, x₂⇐x₁−409=6965, y₂⇐y₁+3678=2869, z₂⇐z₁−ϕ₁=0−2249=−2249

2: stage i=2, θ₂=1, x₂=6965, y₂=2869, z₂=−2249

First Shift to the right, with i−ϵ(i)+1=3 and i−ϵ(i)=2, x₂>>3+x₂>>2=2611, y₂>>3+y₂>>2=1075

Because y₂≥0, x₃⇐x₂−1075=5890, y₃⇐y₂−2611=258, z₃⇐z₂+ϕ₂=−2249+1614=−635

3: stage i=3, θ₃=0, x₃=5890, y₃=258, z₃=−635

First Shift to the right, with i−ϵ(i)+2, x₃>>2=1472, y₃>>2=64

Because y₃≥0, x₄⇐x₃−64=5826, y₄⇐y₃−1472=−1214, z₄⇐z₃+ϕ₃=−635+1046=411

4: stage i=4, θ₄=0, x₄=5826, y₄=−1214, z₄=411

First Shift to the right, with i−ϵ(i)+1=4 and i−ϵ(i)=3, x₄>>4+x₄>>3=1092, y₄>>4+y₄>>3=−228

Because y₄<0, x₅⇐x₄−228=5598, y₅⇐y₄+1092=−122, z₅⇐z₄−ϕ₄=411−777=−366

5: stage i=5, θ₅=0, x₅=5598, y₅=−366, z₁=0

First Shift to the right, with i−ϵ(i)=3, x₅>>3=699, y₅>>3=−16

Because y₅<0, x₆⇐x₅−16=5582, y₆⇐y₅699=577, z₆⇐z₅−ϕ₅=−366−514=−880

6: stage i=6, θ₆=0, x₆=5582, y₆=577, z₆=−880

First Shift to the right, with i−ϵ(i)=4, x₆>>4=348, y₆>>4=36

Because y₆≥0, x₇⇐xy₆−36=5546, y₇⇐y₆−348=229, z₇⇐z₆+ϕ₆=−880+256=−624

7: stage i=7, θ₇=0, x₇=5546, y₇=229, z₁=−624

First Shift to the right, with i−ϵ(i)+1=6 and i−ϵ(i)=5, x₇>>6+x₇>>5=259, y₇>>6+y₇>>5=10

Because y₇≥0, x₈⇐x₇−10=5536, y₈⇐y₇−259=−30, z₈⇐z₇+ϕ₇=−624+192=−432

8: stage i=8, θ₈=0, x₈=5536, y₈=−30, z₈=−432

First Shift to the right, with i−ϵ(i)=5, x₈>>5=173, y₈>>5=−1

Because y₈<0, x₉⇐x₈−1=5535, y₉⇐y₈+173=143, z₉⇐z₈−ϕ₈=−432−128=−560

9: stage i=9, θ₉=0, x₉=5535, y₉=143, z₉=−560

First Shift to the right, with i−ϵ(i)=6, x₉>>6=86, y₉>>6=2

Because y₉≥0, x₁₀⇐x₉−2=5533, y₁₀⇐y₉−86=57, z₁₀⇐z₉+ϕ₉=−560+64=−496

10: stage i=10, θ₁₀=1, x₁₀=5533, y₁₀=57, z₁₀=−496

First Shift to the right, with i−ϵ(i)+1=8 and i−ϵ(i)=7, x₁₀>>8+x₁₀>>7=64, y₁₀>>8+y₁₀>>7=0

Because y₁₀≥0, x₁₁⇐x₁₀−0=5533, y₁₁⇐y₁₀−64=−7, z₁₁⇐z₁₀+ϕ₁₀=−496+48=−448

11: stage i=11, θ₁₁=0, x₁₁=5533, y₁₁=−7, z₁₁=−448

First Shift to the right, with i−ϵ(i)=7, x₁₁>>7=43, y₁₁>>7=−1

Because y₁₁<0, x₁₂⇐x₁₁−1=5532, y₁₂⇐y₁₁+43=36, z₁₂⇐z₁₁−ϕ₁₁=−448−32=−480

12: stage i=12, θ₁₂=1, x₁₂=5532, y₁₂=36, z₁₂=−480

First Shift to the right, with i−ϵ(i)+1=9 and i−ϵ(i)=8, x₁₂>>9+x₁₂>>8=31, y₁₂>>9+y₁₂>>8=0

Because y₁₂≥0, x₁₃⇐x₁₂−0=5532, y₁₃⇐y₁₂−31=5, z₁₃⇐z₁₂+ϕ₁₂=−480+24=−456

The final output value of the second pipelined architecture is −456, which represents −0.1113, and if it is multiplied by 2, the value obtained is −0.222≈ln (0.8003). As the exponential and the logarithm implementations share lots of hardware resources, an architecture (e.g., a hybrid architecture) programmable for any of the two function approximations may be used. Then, the calculation of SoftMax in hardware (e.g., the architecture disclosed in FIG. 6) is discussed. At Step 1, the input resolution may be selected as K_int=4 bits and K_frac=16 bits, the input vector values are selected the same as the ones used in the software implementation, which have been rounded to the chosen precision bits. The value of Cint is chosen to be 12.

{right arrow over (V)}=(−244449, 270664, 86508, −263455, 144835, 30147, 299500, 173015, −224133, 196609)/2¹⁶=(−3.7300, 4.1300, 1.3200, −4.0200, 2.2100, 0.4600, 4.5700, 2.6400, −3.4200, 3.0000). The value In2 will be quantized using 24 bits, with a value of 11629080/2²⁴. By transforming the input vector, the resulting values (e.g., the transformed values V_pi and k_i) may be stored in memory (e.g., the memory 330), shown in Table 1.

TABLE 1
Vpi	Represented Vpi	ki
−17319	−0.2643	−5
43534	0.6643	5
41082	0.6249	1
−36325	−0.5543	−5
8557	0.1306	3
30147	0.4600	0
26943	0.4111	6
36737	0.5606	3
−42429	−0.6474	−4
14904	0.2274	4

At Step 2, the RME1 may be used. In some embodiments, the hybrid architecture may be configured in rotation mode to perform the rotation. In this step, only the {right arrow over (V_p )} values may be transformed, with the {right arrow over (k)} values left untouched until the floating point adder is reached. The same parameters as in the case of the exponential and logarithm calculation may be used, and the {right arrow over (ϕ)} values will be represented with 16 bits.{right arrow over (θ)}=[0,1,0,1,0,0,1,0,0,1,0,1]{right arrow over (ϕ)}=[35999,25836,16738,12435,8235,4101,3074,2048,1024,768,512,384]{right arrow over (∈)}=[0,0,1,1,2,2,2,3,3,3,4,4]The following results (shown in table 2) may be obtained after the exponential calculation is applied to the {right arrow over (V_pi)} values.

TABLE 2
Vpi	fexp(vpi)	ki
−17319	37898	−5
43534	96184	5
41082	92138	1
−36325	28487	−5
8557	56382	3
3-147	78416	0
26943	74822	6
36737	86882	3
−42429	25933	−4
14904	62317	4

At this point, the values for f_exp(v_pi) will then be transformed to make sure the values f_exp(v_pi) are kept in 16 bits precision, then, the calculation of the summation of all the values are calculated using a simple floating point adder (e.g., the floating point register 230). And the calculated mantissa=40189, and the calculated exponent=8. The method to calculate the mantissa and the exponent is shown in FIG. 7B. At Step 3, The mantissa in the floating point register is then sent through the second pipeline architecture (in Vectoring Mode) to calculate the logarithm. The value at the output of the second pipeline architecture will be −15910 for the mantissa value. Then the output of the second pipeline architecture is shifted to the left and the sign is changed to achieve the value 31820, 31820/2¹⁶=0.4855≈ln(40189/2¹⁶).

At Step 4, the values stored in the memory are streamed out, and all the {right arrow over (v_pL)} values are added by the mantissa in the floating point register, and {right arrow over (k)} is subtracted from the exponent in the floating point register. Because of the operation of the {right arrow over (v_pl)} added the mantissa value, the integer part of the values sent to the third pipeline architecture (e.g., the architecture shown in FIG. 6) may not be 0. After performing a second exponential calculation, SoftMax output (shown in Table 3) may be obtained.

TABLE 3
Values in Memory	Added/subtracted	SoftMax Output
vpi	ki	vpi + mantissa	ki − exponent	mantissa	exponent
−17319	−5	14501	−13	61831	−13
43534	5	75354	−3	155983	−3
41082	1	72902	−7	150577	−7
−36325	−5	−4505	−13	46240	−13
8557	3	40377	−5	91414	−5
3-147	0	61967	−8	127639	−8
26943	6	58763	−2	121169	−2
36737	3	68557	−5	141448	−5
−42429	−4	−10609	−12	41835	−12
14904	4	46724	−4	100718	−4

FIG. 8A depicts a flow chart of an exemplary design-time fabric reconfiguration method for a modified CORDIC engine. An exemplary method 800A to obtain a modified CORDIC engine (e.g., the modified CORDIC engine 200) includes, at 805, configuring a vector conversion engine (e.g., the VCE 210) to receive an input vector V representative of a first data set (205) and transform each element V_i of the input vector x into

V_i=V_pi+k_i·ln 2 to generate a second data set (e.g., the second data set 215), −1≤V_pi≤1, and k_i is an integer. The method 800A also includes, at 810, configuring a first rotation mode engine (e.g., the RME1 220) to receive the second data set 215 and perform exponential calculations on the second data set 215 to generate a third data set (e.g., the third data set 225) that includes a third-sub1 data set (e.g., the third-sub1 data set 225a) and a third-sub2 data set (e.g., the third-sub2 data set 225b).

The method 800A also includes, at 815, configuring a floating point register (e.g., the floating point register 230) and coupling the floating point register 230 to the RME1 220 to receive the third data set 225. The method 800A also includes, at 820, configuring a vectoring mode engine (e.g., the VME 240) and coupling the VME 240 to the floating point register 240 to receive the third-sub1 data set 225a and perform logarithm calculations on the third-sub1 data set 225a to generate a fourth-sub1 data set 235a.

The method 800A also includes, at 825, coupling the floating point register 230 to the VME 240 to store the fourth-sub1 data set 235a. The method 800A also includes, at 830, configuring a second RME (e.g., the RME2 250) and couple the RME2 220 to the VCE 210 and the floating point register 230 to receive the third-sub2 data set 225b, the fourth-sub1 data set 235a and the second data set 215 and perform exponential calculations to generate an output data set 255 that may be interpreted as a probability distribution of each element V_i of the input vector V. Thus, by using the modified CORDIC method that mainly based on shifts and adds, and without the need of any multipliers, SoftMax calculations may be easily performed. Accordingly, the implementation of SoftMax calculations may advantageously reduce the cost of silicon area.

FIG. 8B depicts a flowchart of an exemplary run-time method for performing SoftMax calculation using a modified CORD IC engine. An exemplary method 800B to operate the modified CORDIC engine 200, includes, at 835, retrieving an input vector V representative of an input data set. The method 800B also includes, at 840, introducing a variable i and initialize the variable i to 1. The method 800B also includes, at 845, transforming, by a vector conversion engine (e.g., the VCE 210), each element V_i of the input vector V into another expression shown in equation 30 to generate a second data set (e.g., the second data set 215).

The method 800B also includes, at 850, determining (e.g., by the processor 723) whether i=n, n is the number of elements in the input vector V (whether each and every element V_i in the input vector V has been transformed). If not all elements have been transformed, then the variable i is incremented at 855 and the method 800B loops back to 845. If all elements have been transformed, then the method 800B also includes, at 860, storing the second data set 215 in memory (e.g., memory 330) of the VCE 210.

The method 800B also includes, at 865, retrieving, by a first rotation mode engine (e.g., the RME1 220), the second data set 215 and performing exponential calculations on the second data set 215 to generate a third data set 225 comprising a third-sub1 data set 225a and a third-sub2 data set 225b, and at 870, storing the third data set 225 in a floating point register 230.

The method 800B also includes, at 875, retrieving the third-sub1 data set 225a and performing, by a vectoring mode engine (e.g., the VME 240), logarithm calculations to generate a fourth-sub1 data set 235a, and at 880, storing the fourth-sub1 data set 235a in the floating point register 230.

The method 800B also includes, at 885, retrieving the third-sub2 data set 225b, the fourth-sub1 data set 235a, and the second data set 215 and performing, by a second rotation mode engine (e.g., the RME2 250), exponential calculations to generate an output data set (e.g., the output data set 255). Thus, SoftMax calculations may be easily performed by using the modified CORDIC method that mainly based on shifts and adds, and without the need of any multipliers.

In this depicted example, the modified CORDIC engine 200 is arranged on a single integrated circuit. The integrated circuit may be a field programmable gate array (FPGA). In some embodiments, the modified CORDIC engine 200 may be implemented as hard block fixed circuitry. For example, an application specific integrated circuit (ASIC) may provide a modified CORDIC engine with customized hardware circuitry.

In some embodiments, some or all of the functions of modified CORDIC engine 200 may be implemented in a different integrated circuit. For example, the VCE 210 may be implemented in an ASIC, and the RME1 220 and the RME2 250 may be implemented in a FPGA.

In some embodiments, some or all of the functions of modified CORDIC engine 200 may be implemented in a processor that is configured to execute a set of instructions stored in a data store to perform SoftMax calculation. The processor may be arranged on the same integrated circuit with the data store. The data store may be implemented in a programmable logic block of a system-on-chip (SOC) or implemented in a hard block using fixed circuitry of the SOC.

FIG. 9 illustrates an exemplary architecture for a System-on-Chip (SOC). SOC 900 is an example of a programmable IC and an integrated programmable device platform. In the example of FIG. 9, the various, different subsystems or regions of the SOC 900 illustrated may be implemented on a single die provided within a single integrated package. In other examples, the different subsystems may be implemented on a plurality of interconnected dies provided as a single, integrated package.

In the example, the SOC 900 includes a plurality of regions having circuitry with different functionalities. In the example, the SOC 900 optionally includes a data processing engine (DPE) array 902. SOC 900 includes programmable logic (PL) regions 904 (hereafter PL region(s) or PL), a processing system (PS) 906, a Network on-Chip (NOC) 908, and one or more hardwired circuit blocks 910. DPE array 902 is implemented as a plurality of interconnected, hardwired, and programmable processors having an interface to the other regions of the SOC 900.

PL 904 is circuitry that may be programmed to perform specified functions. As an example, PL 904 may be implemented as field programmable gate array type of circuitry. PL 904 can include an array of programmable circuit blocks. Examples of programmable circuit blocks within PL 904 include, but are not limited to, configurable logic blocks (CLBs), dedicated random access memory blocks (BRAM and/or UltraRAM or URAM), digital signal processing blocks (DSPs), clock managers, and/or delay lock loops (DLLs).

Each programmable circuit block within PL 904 typically includes both programmable interconnect circuitry and programmable logic circuitry. The programmable interconnect circuitry typically includes a large number of interconnect wires of varying lengths interconnected by programmable interconnect points (PIPs). Typically, the interconnect wires are configured (e.g., on a per wire basis) to provide connectivity on a per-bit basis (e.g., where each wire conveys a single bit of information). The programmable logic circuitry implements the logic of a user design using programmable elements that may include, for example, look-up tables, registers, arithmetic logic, and so forth. The programmable interconnect and programmable logic circuitries may be programmed by loading configuration data into internal configuration memory cells that define how the programmable elements are configured and operate.

The PS 906 is implemented as hardwired circuitry that is fabricated as part of the SOC 900. The PS 906 may be implemented as, or include, any of a variety of different processor types each capable of executing program code. For example, PS 906 may be implemented as an individual processor, e.g., a single core capable of executing program code. In another example, PS 906 may be implemented as a multicore processor. In still another example, PS 906 may include one or more cores, modules, co-processors, interfaces, and/or other resources. PS 906 may be implemented using any of a variety of different types of architectures. Example architectures that may be used to implement PS 906 may include, but are not limited to, an ARM processor architecture, an x86 processor architecture, a GPU architecture, a mobile processor architecture, a DSP architecture, or other suitable architecture that is capable of executing computer-readable instructions or program code.

NOC 908 includes an interconnecting network for sharing data between endpoint circuits in SOC 900. The endpoint circuits can be disposed in DPE array 902, PL regions 904, PS 906, and/or in hardwired circuit blocks 910. NOC 908 can include high-speed data paths with dedicated switching. In an example, NOC 908 includes horizontal paths, vertical paths, or both horizontal and vertical paths. The arrangement and number of regions shown in FIG. 9 is merely an example. The NOC 908 is an example of the common infrastructure that is available within the SOC 900 to connect selected components and/or subsystems.

NOC 908 provides connectivity to PL 904, PS 906, and to selected ones of the hardwired circuit blocks 910. NOC 908 is programmable. In the case of a programmable NOC used with other programmable circuitry, the nets that are to be routed through NOC 908 are unknown until a user circuit design is created for implementation within the SOC 900. NOC 908 may be programmed by loading configuration data into internal configuration registers that define how elements within NOC 908 such as switches and interfaces are configured and operate to pass data from switch to switch and among the NOC interfaces.

NOC 908 is fabricated as part of the SOC 900 and while not physically modifiable, may be programmed to establish connectivity between different master circuits and different slave circuits of a user circuit design. NOC 908, for example, may include a plurality of programmable switches that are capable of establishing packet switched network connecting user specified master circuits and slave circuits. In this regard, NOC 908 is capable of adapting to different circuit designs, where each different circuit design has different combinations of master circuits and slave circuits implemented at different locations in the SOC 900 that may be coupled by NOC 908. NOC 908 may be programmed to route data, e.g., application data and/or configuration data, among the master and slave circuits of the user circuit design. For example, NOC 908 may be programmed to couple different user-specified circuitry implemented within PL 904 with PS 906, and/or DPE array 902, with different hardwired circuit blocks, and/or with different circuits and/or systems external to the SOC 900.

The hardwired circuit blocks 910 may include input/output (I/O) blocks, and/or transceivers for sending and receiving signals to circuits and/or systems external to SOC 900, memory controllers, or the like. Examples of different I/O blocks may include single-ended and pseudo differential I/Os and high-speed differentially clocked transceivers. Further, the hardwired circuit blocks 910 may be implemented to perform specific functions. Examples of hardwired circuit blocks 910 include, but are not limited to, cryptographic engines, digital-to-analog converters, analog-to-digital converters, and the like. The hardwired circuit blocks 910 within the SOC 900 may be referred to herein from time-to-time as application-specific blocks.

In the example of FIG. 9, PL 904 is shown in two separate regions. In another example, PL 904 may be implemented as a unified region of programmable circuitry. In still another example, PL 904 may be implemented as more than two different regions of programmable circuitry. The particular organization of PL 904 is not intended as a limitation. In this regard, SOC 900 includes one or more PL regions 904, PS 906, and NOC 908. DPE array 902 may be optionally included.

In other example implementations, the SOC 900 may include two or more DPE arrays 902 located in different regions of the IC. In still other examples, the SOC 900 may be implemented as a multi-die IC. In that case, each subsystem may be implemented on a different die. The different dies may be communicatively linked using any of a variety of available multi-die IC technologies such stacking the dies side-by-side on an interposer, using a stacked-die architecture where the IC is implemented as a Multi-Chip Module (MCM), or the like. In the multi-die IC example, it should be appreciated that each die may include single subsystem, two or more subsystems, a subsystem and another partial subsystem, or any combination thereof.

A programmable integrated circuit (IC) refers to a type of device that includes programmable logic. An example of a programmable device or IC is a field programmable gate array (FPGA). An FPGA is characterized by the inclusion of programmable circuit blocks. Examples of programmable circuit blocks include, but are not limited to, input/output blocks (IOBs), configurable logic blocks (CLBs), dedicated random access memory blocks (BRAM), digital signal processing blocks (DSPs), processors, clock managers, and delay lock loops (DLLs). Modern programmable ICs have evolved to include programmable logic in combination with one or more other subsystems. For example, some programmable ICs have evolved into System-on-Chips or “SOCs” that include both programmable logic and a hardwired processor. Other varieties of programmable ICs include additional and/or different subsystems.

Although various embodiments have been described with reference to the figures, other embodiments are possible. For example, memory 330 arranged in the VCE 210 may be placed in the modified CORDIC engine 200. In some embodiments, the floating point register 230 may be coupled to the VCE 210 the store the second data set 215.

Various examples may be implemented using circuitry, including various electronic hardware. By way of example and not limitation, the hardware may include transistors, resistors, capacitors, switches, integrated circuits and/or other devices. In various examples, the circuits may include analog and/or digital logic, discrete components, traces and/or memory circuits fabricated on a silicon substrate including various integrated circuits (e.g., FPGAs, ASICs). In some embodiments, the circuits may involve execution of preprogrammed instructions and/or software executed by a processor. For example, various systems may involve both hardware and software.

Some aspects of embodiments may be implemented as a computer system. For example, various implementations may include digital and/or analog circuitry, computer hardware, firmware, software, or combinations thereof. Apparatus elements can be implemented in a computer program product tangibly embodied in an information carrier, e.g., in a machine-readable storage device, for execution by a fixed hardware processor; and methods can be performed by a programmable processor executing a program of instructions to perform functions of various embodiments by operating on input data and generating an output. Some embodiments may be implemented advantageously in one or more computer programs that are executable on a programmable system including at least one processor coupled to receive data and instructions from, and to transmit data and instructions to, a data store, at least one input, and/or at least one output. A data store may include one or more registers or memory locations in, for example, a memory space. A computer program is a set of instructions that can be used, directly or indirectly, in a computer to perform a certain activity or bring about a certain result. A computer program can be written in any form of programming language, including compiled or interpreted languages, and it can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other units suitable for use in a computing environment.

In various embodiments, a computer system may include non-transitory memory. The memory may be connected to the one or more processors, which may be configured for storing data and computer readable instructions, including processor executable program instructions. The data and computer readable instructions may be accessible to the one or more processors. The processor executable program instructions, when executed by the one or more processors, may cause the one or more processors to perform various operations.

A number of implementations have been described. Nevertheless, it will be understood that various modification may be made. For example, advantageous results may be achieved if the steps of the disclosed techniques were performed in a different sequence, or if components of the disclosed systems were combined in a different manner, or if the components were supplemented with other components. Accordingly, other implementations are within the scope of the following claims.

Claims

1. A system comprising: a first circuit configured to receive an input vector V representative of a first data set and transform each element Vi of the input vector V into Vi=Vpi+ki·ln 2 to generate a second data set, the second data set comprising a first sub data set that has Vpi and a second sub data set that has ki, wherein −1≤Vpi≤1, and each ki is an integer;a second circuit configured to receive the second data set from the first circuit and perform first exponential calculations on the second data set to generate a third data set, the third data set comprising a third sub data set that has a first mantissa

2. The system of claim 1, wherein the first circuit comprises: a demultiplexer configured to receive each element Vi of the input vector V representative of the first data set;Kint transformation circuits commonly coupled to the output of the demultiplexer to perform sequential subtraction of value In2 to an absolute value of element Vi;Kint casting circuits, each casting circuit of the Kint casting circuits is coupled to a transformation circuit of the Kint transformation circuits; anda multiplexer coupled to receive outputs from the Kint transformation circuits and outputs from the Kint casting circuits to generate the first sub data set that has Vpi and the second sub data set that has ki.

3. The system of claim 2, wherein the first circuit further comprises: a data store configured to store the first sub data set that has Vpi and the second sub data set that has ki.

4. The system of claim 1, wherein the second circuit comprises: a first N-stage pipelined CORDIC circuit configured to receive the first sub data set that has Vpi and perform the first exponential calculations on the first sub data set that has Vpi to generate a sixth sub data set that has fexp(Vpi);a delay circuit configured to introduce a delay on the second sub data set that has ki to match a delay introduced by the first N-stage pipelined CORDIC circuit; anda state machine coupled to the first N-stage pipelined CORDIC circuit and the delay circuit to perform operations on the sixth sub data set to make an integer part of fexp(Vpi)≤1.

5. The system of claim 4, wherein the operations further comprise: if fexp(Vpi)>1, right shifting fexp(Vpi) and increasing a corresponding ki.

6. The system of claim 5, wherein the second circuit further comprises: a floating point adder coupled to the state machine to perform summation on every fexp(Vpi); anda floating point register coupled to the floating point adder to generate and store the third sub data set and the fourth sub data set.

7. The system of claim 6, wherein the third circuit comprises: a second N-stage pipelined CORDIC circuit coupled to the floating point register to receive the third sub data set that has the first mantissa

8. The system of claim 7, wherein the fourth circuit comprises: a summing circuit configured to retrieve the first sub data set that has Vpi from a data store and retrieve the fifth sub data set that has the second mantissa Vtotal2 from the floating point register and generate a seventh sub data set;a subtracting circuit configured to retrieve the second sub data set that has ki from memory and retrieve the fourth data set that has the first exponent Ktotal from the floating point register and subtract the first exponent Ktotal from ki to generate an eighth sub data set;a N-stage pipelined CORDIC circuit coupled to the output of the summing circuit and configured to perform the second exponential calculations on the seventh sub data set to generate a ninth sub data set that has

9. A method comprising: (a) receiving, at a first circuit, an input vector V representative of a first data set and transforming each element Vi of the input vector V into Vi=Vpi+ki·ln 2 to generate a second data set, the second data set comprising a first sub data set that has Vpi and a second sub data set that has ki, wherein −1≤Vpi≤1, and ki is an integer;(b) receiving, at a second circuit, the second data set and performing first exponential calculations on the second data set to generate a third data set, the third data set comprising a third sub data set that has a first mantissa

10. The method of claim 9, further comprising: (a1) receiving each element Vi of the input vector V representative of the first data set; and(a2) performing sequential subtraction of value In2 to an absolute value of element Vi.

11. The method of claim 10, further comprising: (b1) performing the first exponential calculations on the first sub data set that has Vpi to generate a sixth sub data set that has fexp(Vpi); and(b2) if fexp(Vpi)>1, right shifting fexp(Vpi) and increasing a corresponding ki to make an integer part of fexp(Vpi)≤1.

12. The method of claim 11, further comprising: (b3) performing summation on every fexp(Vpi); and(b4) generating and storing the third sub data set and the fourth sub data set.

13. The method of claim 12, further comprising: (c1) retrieving the third sub data set that has the first mantissa