Efficient multiply-accumulate unit for convolutional neural network processing including maximum pooling

By introducing enhanced MAC units into the matrix processor, using the combination of multiplexer and accumulator, the problems of maximum pooling operation complexity and high power in the prior art are solved, and more efficient convolutional nerves are achieved Network processing performance, suitable for autonomous or semi-autonomous vehicles.

CN119032340APending Publication Date: 2024-11-26TESLA INC
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202380033714.X
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Priority Date
2022-03-04
Filing Date
2023-03-02
Publication Date
2024-11-26

AI Technical Summary

Technical Problem

When existing matrix processors perform convolutional neural network operations, especially when maximum pooling operations, the complexity and chip space are high, and the power requirements are high, making it difficult to meet the performance requirements of autonomous or semi-autonomous driving vehicles. .

Method used

An enhanced multiplication accumulation unit (MAC unit) is designed. Through the combination of multiplexer and accumulator, it can dynamically adjust according to the operation type (convolution or maximum pooling), improve processing efficiency, and pass negative Weight multiplication and accumulated value comparison enable the identification and storage of maximum or minimum values, reducing hardware complexity and power consumption.

Benefits of technology

Through enhanced MAC units, the complexity and space occupancy of the matrix processor are reduced, and the performance of convolutional neural network operation is improved. Especially in the process of maximum pooling, more efficient information processing and power management are achieved, suitable for Autonomous or semi-autonomous driving vehicles.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN119032340A_ABST
    Figure CN119032340A_ABST
Patent Text Reader

Abstract

Systems and methods for an enhanced multiply-accumulate unit for convolutional neural network processing. An example multiply-accumulate unit includes a multiplier configured to receive (1) an input value of an input value window and (2) a weight value set to negative 1. The unit also includes an adder configured to add a result received from the multiplier to a value in an accumulator of the MAC unit. The unit further comprises a multiplexer configured to select between outputting (1) a result of the adder and (2) an input value; and an accumulator configured to receive an output from the multiplexer, and configured to be enabled or disabled according to a result of the adder based on execution of a specific convolution operation by the MAC unit.
Need to check novelty before this filing date? Find Prior Art

Description

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application claims priority to U.S. Provisional Patent Application Serial No. 63 / 316804, filed on March 4, 2022, entitled “EFFICIENT MULTIPLY-ACCUMULATE UNITS FOR CONVOLUTIONAL NEURAL NETWORK PROCESSING INCLUDING MAXPOOLING,” the entire contents of which are incorporated herein by reference. Technical Field

[0003] The present disclosure relates to a hardware processor, and more particularly to an enhanced multiply-accumulate unit. Background Art

[0004] Neural networks are used for different purposes and are increasingly becoming a technological foundation. For example, a neural network may be used to perform object classification on an image acquired via a user device (e.g., a smartphone). In this example, the neural network may represent a convolutional neural network that applies convolutional layers, pooling layers, and one or more fully connected layers to classify objects depicted in an image. As another example, a neural network may be used to convert text between languages. For this example, the neural network may represent a recurrent neural network, a transformer network, etc.

[0005] Typically, a graphics processing unit (GPU) can be used during training or inference. It is understood that a GPU can perform fast mathematical calculations applicable to certain layers of a neural network. For example, a GPU can quickly calculate a forward pass through a fully connected layer based on multiplying different vectors. However, GPUs are not optimized for specific neural network use cases. This can reduce the complexity of a neural network to be able to achieve an inference time that is less than a specific time constraint. For example, a neural network that performs object recognition on images acquired from a camera may be limited in how many images it can process per second. BRIEF DESCRIPTION OF THE DRAWINGS

[0006] Figure 1 is a block diagram illustrating an example prior art matrix processor configured for performing convolutional neural network operations.

[0007] Figure 2A is a block diagram illustrating an example matrix processor including an enhanced multiply-accumulate unit (MAC unit) according to techniques described herein.

[0008] Figure 2B is a block diagram illustrating details of an example MAC unit.

[0009] Figure 3is a flow chart of an example process for performing convolutional neural network operations, such as max pooling, using the enhanced MAC units described herein.

[0010] Figure 4 is a block diagram illustrating an example vehicle including a vehicle processor system.

[0011] Embodiments of the present disclosure and their advantages can be best understood by referring to the following detailed description. It should be understood that the same reference numerals are used to identify the same elements shown in one or more figures, wherein the illustrations in the figures are for illustrating embodiments of the present disclosure, rather than for limiting the present disclosure. DETAILED DESCRIPTION

[0012] The present application describes an enhanced multiply-accumulate (MAC) unit that can be optionally included in a matrix processor along with other MAC units. In some embodiments, the matrix processor can perform convolutional neural network processing (e.g., the matrix processor can be a convolution engine). For example, the matrix processor can calculate the forward pass of information through the layers that form the convolutional neural network. Example information can include images from an image sensor, such as an image sensor located around an autonomous or semi-autonomous vehicle. As described below, the enhanced MAC unit described herein can allow certain operations commonly used in processing related to convolutional neural networks to be performed. An example of such an operation includes pooling, such as maximum pooling.

[0013] An example hardware processor, such as a convolution engine, can be configured for efficient processing of convolutional neural networks. For example, the hardware processor can obtain image data (e.g., vectorized data) and a filter or kernel to be applied to the image data. In this example, the hardware processor can have a matrix processor having a MAC unit matrix configured to at least calculate the dot product between the image data and the filter or kernel. The output of the matrix processor can represent the output of the convolution layer included in the convolutional neural network. The output can also represent the output associated with the individual output channel. Then, a nonlinear activation function can be applied to the above output, for example, via different hardware units or elements.

[0014] With respect to pooling, the hardware processor may include another hardware unit or element that performs pooling. For example, for a max pooling layer, the hardware unit or element may identify a maximum value within a window of values ​​included in the input to the max pooling layer. An example window may be 2×2, for example with a stride of 2, such that the max pooling layer subsamples each depth slice in the input by a factor of 2 along both the width and height. For example, the max pooling layer identifies the maximum value in a first 2×2 input portion and then identifies the maximum value in a second 2×2 output portion that is two width positions away from the first portion.

[0015] It is understood that using a separate hardware unit or element to perform post-processing, such as max pooling, may increase the complexity of the hardware processor and the chip space occupied. In addition, for electric vehicles, the power requirements may be higher.

[0016] An example enhanced MAC unit that enables performance improvements associated with performing max pooling is described herein. As described below, the enhanced MAC unit may include example hardware for enabling performance of max pooling. One example of such hardware includes a multiplexer, such as a 2-to-1 multiplexer, that multiplexes between (1) input data and (2) an output of an addition operation that adds an accumulated value to the product of the input data and weight data (e.g., kernel or filter data). The multiplexer may select between two multiplexed sources depending on whether a first operation (e.g., convolution) is being performed or a second operation (e.g., max pooling) is being performed.

[0017] To allow for maximum pooling, and thereby compare values ​​in an input value window, the enhanced MAC unit may receive (1) an input value in the input value window and (2) a weight of negative 1. Thus, the product of these values ​​may represent a negative value of the input value. The multiplication may be added to an accumulated value (such as a previous input value in the input value window), and the comparison may be identified based on the addition. For example, the high bit of the result may indicate whether the input value is greater than or less than the previous value. If the result is greater, the input value may be stored as an accumulated value (e.g., in an accumulator element). For example, the accumulator may be enabled based on the value of the high bit. If the result is smaller, the accumulated value may remain at the previous value. For example, the accumulator may be disabled based on the value of the high bit. In these examples, the high bit may therefore be input into the enable / disable of the accumulator.

[0018] Thus, the enhanced MAC unit described above can be utilized to reduce the complexity and / or update size associated with a matrix processor for autonomous or semi-autonomous driving. In fact, by using multiplexers to adjust the MAC unit, information can be processed more efficiently and complexity can be reduced.

[0019] The MAC unit may be included in a matrix processor, such as the matrix processors described in U.S. Patent No. 11,157,287, U.S. Patent Publication No. 2019 / 0026250, and U.S. Patent No. 11,157,441, the entire contents of which are incorporated herein by reference and constitute a part of the present disclosure, as described herein. In some embodiments, the matrix processor is a non-systolic array of MAC units, wherein input data is provided to one direction of the matrix processor and weight data is provided to a second direction of the matrix processor.

[0020] In some embodiments, the MAC units described herein (e.g., enhanced MAC units) may be arranged so that a tree reduction may be performed. For example, a first number of MAC units may determine the maximum value of their respective portions in the input window. For example, 4 MAC units may determine the maximum value of a 4×4 submatrix of an 8×8 input window. The outputs (e.g., 4 values) of the 4 MAC units may be provided to a single MAC unit to determine the maximum value. The output may also be provided to two MAC units (e.g., such as providing 2 values ​​to each MAC unit in consecutive clock cycles) and then to 1 MAC unit to determine the maximum value.

[0021] It will be appreciated that various topologies of the MAC units described herein may be used in a processor and fall within the scope of the disclosure herein.

[0022] In some embodiments, the techniques described herein can be used to determine the minimum value in a pooling window. For example, the accumulator can initially store a default value described herein (e.g., the highest representable value). In this example, the input data value multiplied by negative 1 can be added to the default value, and based on the high bit indicating that the addition is positive, the accumulator can be enabled to store the input data value.

[0023] block diagram

[0024] Figure 1 is a block diagram illustrating an example prior art matrix processor 100 configured for performing convolutional neural network operations. The example matrix processor 100 includes a plurality of multiply-accumulate units (MAC units) that can process convolutional layers of a convolutional neural network.

[0025] As an example, the matrix processor 100 may receive input data along direction A 102 of the matrix processor 100. For example, the input data may represent a vectorized form of one or more images acquired from an image sensor. As another example, the matrix processor 100 may receive weight data (e.g., one or more filters, kernels) along direction B 104 of the matrix processor 100. For example, the weight data may represent a vectorized form of the weight data.

[0026] The matrix processor 100 may use multiple MAC units to calculate one or more convolutions associated with the input data and the weight data. For example, the MAC unit may calculate the dot product of portions of the input data and the weight data. These dot products may be used to generate one or more convolutions.

[0027] Figure 11 includes an example MAC unit 110. As shown, the MAC unit 110 includes a first element that multiplies the input data and the weight data. In addition, the MAC unit 110 includes a second element that adds the result of the first element to the accumulated value stored in the accumulator. In this way, the multiplication of the weight data and the input data can be added within a clock cycle of the matrix processor 100.

[0028] Although the matrix processor 100 can efficiently perform convolution using the MAC unit, the MAC unit lacks the ability to perform other operations commonly used in convolutional neural networks. For example, the matrix processor 100 may require additional hardware elements to perform maximum pooling.

[0029] Figure 2A is a block diagram illustrating an example matrix processor 200 including an enhanced multiply-accumulate unit (MAC unit) according to the techniques described herein. The matrix processor 200 includes an example of an enhanced MAC unit 210 according to the techniques described herein. The example matrix processor 200 can be used to perform convolutional neural network processing, for example, one output channel is active for a given data input channel. It is understood that this can adjust normal operation (for example, pooling can traditionally be in the depth direction).

[0030] The enhanced MAC unit 210 may be used to calculate or determine a maximum value of a set of input values. In the illustrated embodiment, the enhanced MAC unit 210 receives input values ​​212. For example, the input values ​​212 may represent input values ​​from an input value window associated with the size of the max pooling operation being performed. Example sizes may include 2×2 operations, 3×3 operations, etc. The values ​​in the input value window may be continuously provided to the enhanced MAC unit 210 to enable comparison of these input values.

[0031] The enhanced MAC unit 210 additionally receives a weight value of negative 1, thereby causing the input value 212 to be negative. For example, the matrix processor 200 or a controller associated with the processor 200 may cause the weight to be a value of negative 1. In this example, instructions associated with performing maximum pooling may cause the weight value to be input. As described below, Figure 2B , the negative input value 212 can be added to the previous input value in the accumulator. Therefore, the result of the addition can indicate whether the input value 212 is greater than the previous input value.

[0032] The enhanced MAC unit 210 also includes a multiplexer 216. During processing of the convolution layer, the multiplexer 216 can be set to select from a first source (e.g., the output of the addition). For example, the matrix processor 200 can execute a software or hardware command or instruction that causes the selection of the first source. In this way, the multiplexer 216 can pass the value output from the addition to be included or stored in the accumulator. During processing of the maximum pooling layer, the multiplexer 216 can be set to select from a second source (e.g., input data). Therefore, depending on whether the input data is greater than (e.g., greater than, greater than, or equal to) the previous input value, the input data can be stored in the accumulator.

[0033] Figure 2B is a block diagram illustrating details of an example enhanced MAC unit 210. As described above, Figure 2A , input data 212 (e.g., input values) may be provided to the enhanced MAC unit 210 along with weight data 214 set to negative 1. For example, when the matrix processor 200 is performing a max pooling operation, software or hardware operations may cause the weight data 214 to be set to negative 1.

[0034] In the example shown, the multiplexer 216 is set to select a particular source (e.g., input data 212) via a selector 218. For example, the selector 218 can switch between sources based on whether the matrix processor 200 is processing a convolutional layer or a max pooling layer. In this example, the selector 218 can be set based on the instruction being executed.

[0035] An example operation of the enhanced MAC unit 210 may include the input data 212 being the first value in the input value window. In this example, there may be no accumulated value, so the value is set to a default value (e.g., zero). The input data 212 is multiplied by negative 1, and the output of the multiplication is added to the default value. Since in some embodiments, the first value may be positive (e.g., assuming the input is image data), the result of the addition will be negative. For example, if the first value is 7, the multiplication will be negative 7, and the result of the addition will remain negative 7.

[0036] For default values, the accumulator may be reset before determining the maximum value in the value window. For example, when finding the maximum value in a series of unsigned values, the accumulator may be reset to zero (e.g., the minimum unsigned value). As another example, when performing a maximum value in a signed value, the reset value may be the smallest negative number representable by the input data width of the MAC (e.g., 0×ffff…). An alternative to these reset cases is to simply override the circuitry to capture the first data into the accumulator, and thus no reset value is required.

[0037] In the above example, since the result of the addition is negative, the high bit 220 will be set to a specific value (e.g., 1 relative to the signed magnitude representation). For example, when processing a maximum pooling layer, the high bit can be used to enable or disable the accumulator. For example, since the high bit 220 is 1, the accumulator will be enabled. Therefore, the input data 212 will be transmitted through the multiplexer 216 and stored or included in the accumulator.

[0038] Subsequently, the next input value in the input value window can be obtained. In certain embodiments, the next input value can be provided in a subsequent clock cycle. Similar to the above, the next input value will be multiplied by negative 1, and the multiplication result is added to the accumulated value. If the next input value is greater than the accumulated value, then the high position 220 will be set to 1, and the accumulator will store the next output value. However, if the next input value is less than the accumulated value, then the high position 220 will be set to zero, and the accumulator will be disabled. In this way, the accumulated value will be retained.

[0039] After the final value within the value window is processed by the enhanced MAC unit 210, the value stored in the accumulator will represent the maximum value within the value window.

[0040] In some embodiments, when processing a convolutional layer, the high bit 216 may be ignored or set to 1. In this way, the accumulator may function normally. However, when processing a pooling layer, the high bit may be used to indicate whether the accumulator should be enabled or disabled.

[0041] Example Flowchart

[0042] Figure 3 1 is a flow chart of an example process 300 for performing a convolutional neural network operation, such as max pooling, using the enhanced MAC units described herein. For convenience, process 300 will be described as being performed by a matrix processor including a plurality of enhanced multiply-accumulate units (MAC units).

[0043] At block 302, the matrix processor causes the convolution engine to perform max pooling. The matrix processor, which may be referred to as the convolution engine, may execute one or more instructions associated with max pooling performance. For example, in some embodiments, max pooling may be defined via an indication of input data, a window size, a stride, etc. The input data may represent the output of a previous layer of a neural network, and may be a previous pooling layer, a previous convolution layer, etc.

[0044] As described above, the enhanced MAC unit can be configured for maximum pooling. For example, a selector (e.g., selector 218) of a multiplexer included in the enhanced MAC unit can be set to a specific value that results in selection of input data. In this example, the output of the multiplexer can be routed to an accumulator in the enhanced MAC unit. Thus, the enhanced MAC unit can be configured to store input data routed through the multiplexer.

[0045] At block 304, the matrix processor provides a portion of the input data to the enhanced MAC unit. As described above, max pooling may represent identifying corresponding maximum values ​​in multiple windows of input values. For example, the size of the max pooling window may be 2×2, and the stride may be set to 2. In this example, for ease of reference, the input data may include 4 windows (e.g., the input data may have 16 values). In some embodiments, each of the enhanced MAC units may operate on a corresponding window. For four windows, four enhanced MAC units may identify corresponding maximum values ​​in the four windows.

[0046] At block 306, the matrix processor causes a comparison of the input data. Figure 2A-2B As shown, each enhanced MAC unit can identify the maximum value in the corresponding window.

[0047] Vehicle Block Diagram

[0048] Figure 4 A block diagram of a vehicle 400 (e.g., vehicle 102) is illustrated. The vehicle 400 may include one or more motors 402 that cause movement of the vehicle 400. The motors 402 may include, for example, induction motors, permanent magnet motors, etc. As known to those skilled in the art, a battery 404 (e.g., one or more battery packs, each battery pack including a plurality of batteries) may be used to power the motors 402.

[0049] Vehicle 400 also includes a propulsion system 406 that can be used to set the gear (eg, propulsion direction) of the vehicle. For an electric vehicle, propulsion system 406 can adjust the operation of electric motor 402 to change the propulsion direction.

[0050] In addition, the vehicle includes a matrix processor 200 that includes a plurality of enhanced multiply-accumulate units (MAC units) described herein. The matrix processor 200 can process data, such as images received from image sensors (e.g., cameras 104A-104N) located around the vehicle 400. The vehicle processor system 100 can additionally output information to and receive information (e.g., user input) from a display 408 included in the vehicle 400.

[0051] Other embodiments

[0052] All processes described herein can be embodied and fully automated via software code modules that are executed by a computing system including one or more computers or processors. The code modules can be stored in any type of non-transitory computer-readable medium or other computer storage device. Some or all of these methods can be embodied in dedicated computer hardware.

[0053] It will be apparent from this disclosure that there are many other variations in addition to those described herein. For example, depending on the embodiment, certain actions, events, or functions of any algorithm described herein may be performed in a different order, may be added, merged, or omitted entirely (e.g., not all described actions or events are necessary for algorithm practice). In addition, in some embodiments, actions or events may be performed concurrently, such as by multithreading, interrupt handling, or multiple processors or processor cores, or on other parallel architectures, rather than sequentially. In addition, different tasks or processes may be performed by different machines and / or computing systems that may work together.

[0054] The various illustrative logic blocks, modules, and engines described in conjunction with the embodiments disclosed herein may be implemented or executed by a machine designed to perform the functions described herein, such as a processing unit or processor, a digital signal processor (DSP), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA) or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or any combination thereof. The processor may be a microprocessor, but in an alternative, the processor may be a controller, a microcontroller, or a state machine, a combination thereof, or the like. The processor may include a circuit system configured to process computer executable instructions. In another embodiment, the processor includes an FPGA or other programmable device that performs logic operations without processing computer executable instructions. The processor may also be implemented as a combination of computing devices, such as a combination of a DSP and a microprocessor, a plurality of microprocessors, one or more microprocessors combined with a DSP core, or any other such configuration. Although primarily described herein with respect to digital technology, the processor may also primarily include analog components. For example, some or all of the signal processing algorithms described herein may be implemented in an analog circuit system or a mixed analog and digital circuit system. The computing environment may include any type of computer system, including but not limited to a microprocessor-based computer system, a mainframe computer, a digital signal processor, a portable computing device, a device controller, or a computing engine within an appliance, etc.

[0055] Unless otherwise specifically stated, conditional language such as "can," "could," "might," or "may" is understood in the context of being generally used to convey that certain embodiments include and other embodiments do not include certain features, elements, and / or steps. Thus, such conditional language generally does not indicate that one or more embodiments require the features, elements, and / or steps in any way, nor does it indicate that one or more embodiments must include logic for deciding whether to include or perform such features, elements, or steps in any particular embodiment with or without user input or prompting.

[0056] Unless specifically stated otherwise, negative language, such as the phrase "at least one of X, Y, or Z," should be understood along with the context generally used to indicate that an item, term, etc. can be X, Y, Z, or any combination thereof (e.g., X, Y, and / or Z). Thus, such disjunctive language is generally not intended to, and should not, imply that certain embodiments require that at least one of X, at least one of Y, or at least one of Z are all present.

[0057] Any process description, element or block in the flowcharts described herein and / or shown in the drawings should be understood to potentially represent a code module, segment or portion, which includes one or more executable instructions for implementing a specific logical function or element in the process. Alternative implementations are included within the scope of the embodiments described herein, where elements or functions may be deleted, executed out of the order shown or discussed, including substantially concurrently or in reverse order, depending on the functionality involved.

[0058] Unless expressly stated otherwise, articles such as "a" or "an" should generally be interpreted as including one or more of the items. Thus, phrases such as "a device configured to..." are intended to include one or more of the referenced devices. Such one or more referenced devices may also be collectively configured to perform the references. For example, "a processor configured to perform references A, B, and C" may include a first processor configured to perform reference A, the first processor working in conjunction with a second processor configured to perform references B and C.

[0059] It should be emphasized that many changes and modifications may be made to the above-described embodiments, and its elements should be understood as one of other acceptable examples. All such modifications and changes are intended to be included within the scope of the present disclosure.

Claims

1. A multiply-accumulate unit (MAC unit) included in a matrix processor, the matrix processor being configured to compute a forward pass through a neural network, and the matrix processor being configured for inclusion in a vehicle, wherein the MAC unit comprises: a multiplier, wherein the multiplier is configured to receive (1) an input value of an input value window and (2) a weight value set to negative 1; an adder, wherein the adder is configured to add a result received from the multiplier to a value in an accumulator of the MAC unit; a multiplexer, wherein the multiplexer is configured to select between outputting (1) a result of the adder and (2) the input value; as well as The accumulator, wherein the accumulator is configured to receive an output from the multiplexer, and wherein the accumulator is configured to be enabled or disabled according to the result of the adder based on the MAC unit performing a particular convolution operation. 2 . The MAC unit according to claim 1 , wherein the MAC unit is configured to continuously receive individual input values ​​within the input value window. 3 . The MAC unit of claim 2 , wherein the MAC unit is configured to identify a maximum value within the window of input values.

4. The MAC unit of claim 1, wherein the specific convolution operation is maximum pooling. The MAC unit according to claim 4 , wherein the multiplexer is configured to select and output the input value.

6. The MAC unit of claim 1 , wherein the particular convolution operation is max pooling, and wherein the multiplexer is configured to select the result of the adder based on the MAC unit performing processing associated with a convolutional layer.

7. The MAC unit of claim 1, wherein the particular convolution operation is maximum pooling, and wherein based on the MAC unit performing processing associated with a convolutional layer, the accumulator is configured to be enabled during execution of the processing.

8. The MAC unit of claim 1, wherein the particular convolution operation is max pooling, and wherein an upper bit of the result of the adder is used to enable or disable the accumulator.

9. The MAC unit of claim 1, wherein the accumulator is configured to store the input value based on the input value being greater than a different value stored in the accumulator.

10. The MAC unit of claim 9, wherein the accumulator is configured to be enabled such that the accumulator is configured to store the input value.

11. The MAC unit of claim 1 , wherein based on the input value being less than a different value stored in the accumulator, the accumulator is configured to be disabled such that the accumulator does not store the input value.

12. A matrix processor comprising a plurality of multiplication-accumulation units (MAC units) according to claim 1.

13. The matrix processor of claim 12, wherein each MAC unit is configured to identify a maximum value of a different input value window among the plurality of input value windows.

14. A method implemented by a matrix processor, the method comprising: Obtaining information indicating that the matrix processor is to perform maximum pooling; Portions of the input data are provided to corresponding multiplication-accumulation units (MAC units), where each MAC unit includes: a multiplier, wherein the multiplier is configured to receive (1) an input value of an individual portion of the input value and (2) a weight value set to negative 1; an adder, wherein the adder is configured to add a result received from the multiplier to a value in an accumulator of the MAC unit; a multiplexer, wherein the multiplexer is configured to select between outputting (1) a result of the adder and (2) the input value; and the accumulator, wherein the accumulator is configured to receive an output from the multiplexer, and wherein the accumulator is configured to be enabled or disabled based on the result of the adder based on the MAC unit performing a particular convolution operation; and A comparison of input values ​​included in the input value window is caused by the MAC unit.

15. The method of claim 14, wherein the MAC unit is configured to continuously receive individual input values ​​within the input value window. The method of claim 15 , wherein the MAC unit is configured to identify a maximum value within the window of input values.

17. The method of claim 14, wherein the specific convolution operation is max pooling. The method of claim 14 , wherein the multiplexer is configured to selectively output the input value.

19. The MAC unit of claim 1, wherein the particular convolution operation is max pooling, and wherein the multiplexer is configured to select the result of the adder based on the MAC unit performing processing associated with a convolutional layer.

20. The method of claim 14, wherein the particular convolution operation is max pooling, and wherein a high bit of the result of the adder is used to enable or disable the accumulator.

21. The method of claim 20, wherein the accumulator is configured to store the input value based on the input value being greater than a different value stored in the accumulator, and wherein the accumulator is enabled based on a high bit associated with the result of the adder.

22. The method of claim 14, wherein based on the input value being less than a different value stored in the accumulator, the accumulator is configured to be disabled such that the accumulator does not store the input value.