Patent Publication Number: US-2023135185-A1

Title: Pooling unit for deep learning acceleration

Description:
BACKGROUND 
     Technical Field 
     The present disclosure generally relates to convolutional neural networks implemented in electronic systems. 
     Description of the Related Art 
     Deep learning algorithms promote very high performance in numerous applications involving recognition, identification and/or classification tasks, however, such advancement may come at the price of significant requirements in terms of processing power. Thus, their adoption can be hindered by a lack of availability of low-cost and energy-efficient solutions. Accordingly, severe performance specifications may coexist with tight constraints in terms of power and energy consumption while deploying deep learning applications on embedded devices. 
     BRIEF SUMMARY 
     One embodiment is a pooling unit of a convolutional neural network. The pooling unit includes a cropper configured to receive a feature tensor and to generate a cropped feature tensor including a plurality of data values by cropping the feature tensor. The pooling unit includes a line buffer configured to receive the data values from the cropper, a column calculator configured to perform column pooling operations on data columns from the line buffer, and a row calculator configured to perform row pooling operations on data rows from the column calculator. 
     One embodiment is a method including receiving, in a pooling unit of a convolutional neural network, a feature tensor and generating a cropped feature tensor including a plurality of data values by cropping the feature tensor with a cropper of the pooling unit. The method includes passing the data values of the cropped feature tensor to a single ported line buffer of the pooling unit. The method includes generating pooled feature data by performing column and row pooling calculations on the data values from the line buffer 
     One embodiment is a method. The method includes receiving, in a pooling unit of a convolutional neural network, a feature tensor, storing, in a configuration register of the pooling unit, pooling window size data, and generating, with the pooling unit, a plurality of pooling windows from the feature tensor in accordance with the pooling window size data. The method includes generating pooled feature data by performing column and row pooling calculations on the data values from the pooling windows. 
    
    
     
       BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS 
         FIG.  1    is a block diagram of an electronic device, according to one embodiment. 
         FIG.  2    is a block diagram of process flow within a convolutional neural network, according to one embodiment. 
         FIG.  3    is a representation of a feature tensor, according to one embodiment. 
         FIG.  4    is a block diagram of a pooling unit, according to one embodiment. 
         FIG.  5 A  is an illustration of the cropping operation performed by a cropper, according to one embodiment. 
         FIG.  5 B  is an illustration of a cropping operation of a cropper, according to one embodiment. 
         FIG.  6 A  is an illustration of the line buffer of a pooling unit, according to one embodiment. 
         FIG.  6 B  illustrates an operation of the line buffer of a pooling unit, according to one embodiment. 
         FIG.  7 A  illustrates an operation of the padding control of a pooling unit, according to one embodiment. 
         FIG.  7 B  is an illustration of the column calculator of a pooling unit, according to one embodiment. 
         FIG.  8    illustrates an operation of the batch buffer of a pooling unit, according to one embodiment. 
         FIG.  9    illustrates an operation of the batch buffer and the row calculator of a pooling unit, according to one embodiment. 
         FIG.  10    illustrates a pooling operation performed by a pooling unit, according to one embodiment. 
         FIG.  11    is flow diagram of a method for operating a convolutional neural network, according to one embodiment. 
         FIG.  12    is flow diagram of a method for operating a convolutional neural network, according to one embodiment. 
     
    
    
     DETAILED DESCRIPTION 
       FIG.  1    is a block diagram of an electronic device  100 , according to one embodiment. The electronic device  100  includes a convolutional neural network (CNN)  102 . The CNN  102  receives input data  110  and generates prediction data  112  based on the input data  110 . The CNN  102  generates the prediction data  112  by performing one or more convolutional operations on the input data  110 . 
     In one embodiment, the input data  110  is provided by an image sensor (not shown) or another type of sensor of the electronic device  100 . Accordingly, the input data  110  can include image data corresponding to one or more images captured by the image sensor. The image data is formatted so that it can be received by the CNN  102 . The CNN  102  analyzes the input data  110  and generates the prediction data  112 . The prediction data  112  indicates a prediction or classification related to one or more aspects of the image data. The prediction data  112  can correspond to recognizing shapes, objects, faces, or other aspects of an image. While some embodiments herein describe that input data  110  is received from a sensor or sensor system, the input data  110  can be received from other types of systems or devices without departing from the scope of the present disclosure. For example, the input data may  110  may include a data structure stored in a memory and containing statistical data collected and stored by an external CPU. Other types of input data  110  can be utilized without departing from the scope of the present disclosure. 
     In one embodiment, the CNN  102  is trained with a machine learning process to recognize aspects of training images that are provided to the CNN  102 . The machine learning process includes passing a plurality of training images with known features to the CNN. The machine learning process trains the CNN  102  to generate prediction data that accurately predicts or classifies the features of the training images. The training process can include a deep learning process. 
     The CNN  102  includes a plurality of convolution units  104  and a pooling unit  106 . The convolution units  104  implement convolution layers of the CNN  102 . Accordingly, each convolution unit is the hardware block that performs the convolution operations corresponding to a convolution layer. The pooling unit  106  implements pooling functions between the convolution layers. The convolution units  104  and the pooling unit  106  cooperate in generating prediction data  112  from the input data  110 . 
     In one embodiment, each convolution unit  104  includes a convolution accelerator. Each convolution unit  104  performs convolution operations on feature data provided to the convolution unit  104 . The feature data is generated from the input data  110 . The convolution operations at a convolution layer convolve the feature data with kernel data generated during the machine learning process for the CNN  102 . The convolution operations result in feature data that is changed in accordance with the kernel data. The new feature data is provided from one convolution unit  104  to the next convolution unit  104 . 
     Pooling operations are performed on the feature data between convolution layers. When feature data is passed from one convolution layer to the next convolution layer, pooling operations are performed on the feature data to prepare the feature data for the convolution operations of the next convolution layer. The pooling unit  106  performs the pooling operations between convolution layers. The pooling unit  106  is used to accelerate convolutional neural network operations. The pooling unit  106  can perform max pooling operations, minimum pooling operations, average pooling operations, or other types of pooling operations. 
     The output of a convolution layer is a tensor or series of sensors. Tensors are similar to matrices in that they include a plurality of rows and columns with data values in the various data fields. A pooling operation takes a portion, such as a pooling window, of a feature tensor and generates a pooled sub-tensor of reduced dimension compared to the pooling operation. Each data field in the pooled sub-tensor is generated by performing a particular type of mathematical operation on a plurality of data fields (such as taking the maximum value, the minimum value, or the average value from those data fields) from the feature tensor. The pooling operations are performed on each portion of the feature tensor. 
     The various pooling sub-tensors are passed to the next convolution layer as the feature tensor for that convolution layer. Accordingly, pooling helps to reduce data for the next convolution operation and arrange the data for the next convolution operation. 
     For simplicity, the CNN  102  of  FIG.  1    illustrates only convolution units  104  in a pooling unit  106 . However, in practice, the CNN  102  may include many other hardware blocks these other hardware blocks can include batch normalization blocks, scaling blocks, biasing blocks, normalization blocks, activation blocks, and other types of hardware blocks that performs various operations as part of the CNN  102 . 
       FIG.  2    is a simplified block diagram of process flow within a CNN  102 , according to one embodiment. The CNN  102  includes an input layer  120 , a plurality of convolution layers  105 , and one or more connected layers  121 . The input data  110  is provided to the input layer  120  and is passed through the various convolution layers  104  and the fully connected layers  121 . The output of the final fully connected layer is the prediction data  112 . 
     Each convolution layer  105  performs a series of convolution operations on the input data  110 , or on data generated from the input data  110  by the previous layer of the CNN  102 . In particular, kernel data is associated with each convolution layer  105 . Each convolution layer  105  performs convolution operations between the kernel data of that convolution layer  105  and the feature data provided to convolution layer  105 . The feature data is derived from the input data  110 . 
     In one embodiment, the first convolution layer  105  receives feature data from the input layer  120 . The feature data for the first convolution layer  105  is the input data  110 . The first convolution layer  105  generates feature data from the input data  110  by performing convolution operations between the feature tensors of the input data  110  and the kernel tensors of the tensor data. The first convolution layer then passes the feature data to the second convolution layer  105 . As used herein, each convolution layer  105  receives feature data and convolves the feature data with kernel data, the output of this convolution operation is also referred to as feature data herein. Thus, each convolution layer  105  receives feature data and generates adjusted feature data based on convolution operations. This adjusted feature data is then passed to the next convolution layer  105 , which further adjusts the feature data by performing convolution operations on the feature data. 
     Pooling operations  107  are performed on the feature data between each convolution layer. As described above, the pooling operations reduce the dimensionality of the feature data by performing arithmetic operations on the feature data. The pooling operations also prepare and organize the feature data for the convolution operations of the next convolution layer  105 . The pooling unit  106  performs the pooling operations  107 . 
     This processes of convolution and pooling repeat until the final convolution layer  107  has performed convolution operations on the received feature data. Pooling operations  107  are performed on the feature data from the final convolution layer  105 . The feature data is then provided to the fully connected layers  122 . The fully connected layers  122  then generate prediction data  112  from the feature data. In one embodiment, pooling operations generate pooled feature data. 
     In practice, the CNN  102  includes other processes than those shown in  FIG.  2   . In particular, the CNN  102  may include batch normalization operations, scaling operations, biasing operations, normalization operations, activation operations, and other types of operations. Furthermore, the output of a pooling operation can be provided to processes, layers, modules or components other than a convolution layer without departing from the scope of the present disclosure. 
       FIG.  3    is a representation of a feature tensor  128 , according to one embodiment. The feature tensor  128  includes a plurality of blocks. Each of these blocks represents a data value. The tensor  128  includes height, width, and depth. While the feature tensor  128  of  FIG.  3    illustrates a 5×5×5 tensor, in practice, the feature tensor  128  may include other height, width, and depth dimensions. 
     In one embodiment, during the pooling operation, the feature tensor  128  is divided into batches. The feature tensor  120  is patched by depth. Pooling operations are performed on the batches from the feature tensor. The pooling operations are performed on the sub-tensors from each batch. Accordingly, each batch is divided into a plurality of sub-tensors. 
       FIG.  4    is a block diagram of a pooling unit  106 , according to one embodiment. The pooling unit  106  as part of the hardware block making up the CNN  102 . The pooling unit  106  includes a stream filter  142 , a cropper  144 , line buffers  146 , padding control  148 , a column calculator  150 , batch buffers  152 , a row calculator  154 , a multiplexer  156 , an average multiplier stage  158 , a stride manager  160 , a multiplexer  162 , and an un-pooling unit  163 . An input stream link  141  provides data to the pooling unit  106 . The pooling unit  106  outputs data to an output stream link  165 . The configuration registers  164  store configuration data for the pooling unit  106 . The pooling unit  106  performs pooling operations between convolution layers of the CNN  102 . 
     The input of the pooling unit  106  is a 3D feature tensor  128  divided into sub-tensors called batches. The 3D feature tensor  128  is streamed into the pooling unit  106  via the input stream link  141 . The width of the stream link  141 , and thus the maximum width of the data carried in the stream link  141  can be configured at design time. 
     In one embodiment, the pooling unit  106  includes the stream filter  142  at the input. The stream filter receives the feature tensor data  128 . The stream filter  142  ensures that only a validated stream is input to the pooling unit  106 . In one embodiment, the stream filter  142  can be augmented with a first in first out (FIFO) buffer to buffer the input data from the stream link  141 . 
     In one embodiment, the feature tensor  128  is read into the pooling unit  106  from the stream link  141  depth first, followed by width left to right, and finally height from top to bottom. Thus, the data is read across the width and height in the classic raster zigzag scan order, in one embodiment. 
     In one embodiment, the cropper  144  is configured to crop the input feature tensor  128 . In some cases, it is possible that pooling operations should only be performed on certain portions of the feature tensor  128 . The cropper  144  can be configured to crop the feature tensor  128  to extract only that portion of the feature tensor  128  on which pooling operations will be performed. 
       FIG.  5 A  is an illustration of the cropping operation performed by the cropper  144 , according to one embodiment. The feature tensor  128  is input to the cropper  144 . The cropper  144  generates a cropped feature tensor  168  from the input feature tensor  128 . 
     The dimensions of the cropped tensor  168  can be selected by a user via the configuration registers  164 . In particular, data can be written to the configuration registers  164  indicating how the cropper  144  should crop input feature tensors  128 . Accordingly, the configuration register includes dedicated configuration data for the cropper  144 . The configuration register can be set with the height, width, and depth indices for cropping the feature tensor  128 . 
       FIG.  5 B  is an illustration of a cropping operation of the cropper  144 , according to one embodiment. The feature tensor  128  is represented by indices  1   a - 9   c,  each representing data positions within the feature tensor  128 .  FIG.  5 B  also illustrates the  168  that will result from performing the cropping operation on the feature tensor  128 . 
       FIG.  5 B  also includes a flattened representation of the feature tensor  128  and the cropped tensor  168 . The flattened representation represents the three-dimensional feature tensor  128  and the cropped tensor  168  as two-dimensional tensors. 
       FIG.  6 A  is an illustration of the line buffer  146  of the pooling unit  106  of  FIG.  4   , according to one embodiment. The line buffer  146  receives an input stream from the cropper  144 . The input stream from the cropper  144  corresponds to the cropped feature tensor  168 . Alternatively, the input stream from the cropper  144  can be the feature tensor  128  if the cropper  144  is not configured to crop the feature tensor  128 . The input stream shown in  FIG.  6 A  corresponds to the indices of the cropped tensor  168  of  FIG.  5 B . 
     The line buffer  146  is organized from internal memory of the pooling unit  106 . The line buffer  146  buffers horizontal lines of the input in memory. The line buffer  146  can, on request, extract and output vertical columns from the storage lines. Additionally, the line buffer  146  allows reuse of previous lines buffered while storing new incoming lines. 
     In one embodiment, the line buffer  146  receives the input stream and outputs the feature data in columns  170 . Each column  170  includes a data value from a particular position in each row of the line buffer  146 . For example, a first column includes the data value from the first position in each row of the line buffer  146 . A second column includes the data values from the second position in each row of the line buffer  146 . A third column corresponds to the data value from the third position in each row of the line buffer  146 , and so on. 
     In one embodiment, the number of lines and the width of the lines defines the size of the memory for the line buffer  146 . For example, a line buffer with five lines can buffer output vertical columns of up to a height of 5. 
       FIG.  6 B  illustrates an operation of the line buffer  146  of the pooling unit  106 , according to one embodiment. In particular,  FIG.  6 B  illustrates the order in which new lines are filled in the line buffer  146  when all existing lines are full. In the example of  FIG.  6 B , a new data line is received at the line buffer  146 . The top line of the line buffer in its current state is replaced with the new data line. Accordingly, the new buffer state includes the new data line in the top row of the line buffer  146 . 
     In one embodiment, the line buffer  146  is a single ported line buffer. This means that the line buffer  146  includes a single input port and a single output port. The result is that the single ported line buffer  146  has very low power consumption and takes up a small area in of integrated circuit. This can be highly beneficial in terms of power consumption, area consumption, and general efficiency for the pooling unit  106 . 
       FIG.  7 A  illustrates an operation of the padding control  148  of the pooling unit  106 , according to one embodiment. The padding controller  148  receives the feature data columns  170  from the line buffer  146 . The padding controller  148  can pad the feature data columns  170  with a user supplied input padding. 
     In some cases, padding may be needed to adjust the size of an input data window to a required pooling window as strides are made across the input. This may mean that additional data columns  170  are needed and/or that each data column needs one or more additional rows. In this case, users can configure the configuration data in the configuration registers  164  to cause the padding control  148  to pad the feature data columns  170 . 
     In the example of  FIG.  7 A , the input feature data columns  170  have a height of two. The padding control  140  is configured to add an extra row of zeros and an extra column of zeros. Accordingly, the padding control  148  generates padded feature data columns  172 . The padded feature data columns  172  include an extra column of zeros and an extra row of zeros in each column. Other padding configurations can be selected without departing from the scope of the present disclosure. The padding control  140  may also be configured to not perform any padding. This case, the output of the padding control  148  is the same as the input of the padding control  148 . 
       FIG.  7 B  is an illustration of the column calculator  150  of the pooling unit  106 , according to one embodiment. The column calculator  150  receives the padded feature data columns  172  from the padding control  148 . The column calculator  150  generates output data  174  including, for each column a respective data value. 
     The output data  174  from the column calculator  150  is based on the type of operation selected for the column calculator  150 . The configuration data in the configuration registers  164  can define the type of operation to be performed by the column calculator  150 . Some examples of types of operations that can be performed by the column calculator are maximum operations, minimum operations, and average operations. 
       FIG.  7 B  illustrates two types of output data  174 . The top output data corresponds to a maximum operation performed by the column calculator  150 . In the maximum operation, the column calculator determines the maximum value for each input column  172 . The column calculator  150  outputs, for each input,  172  a data value corresponding to the maximum of the data values in that column. In the example of  FIG.  7 B , the maximum value of the first input column  172  is  6 , the maximum value of the second input column  172  is  4 , and the maximum value of the third input column  172  is  2 . Accordingly, the output data  174  for the maximum operation is  6 ,  4 , and  2 . 
     The bottom output data  174  corresponds to a sum calculation of the column calculator  150 . For the sum calculation, the column calculator  150  generates, for each input column  172 , the sum of the data values in the input column  172 . The sum of the data values in the first input column  172  is  11 . The sum of the data values in the second input column  172  is  7 . The sum of the data values in the third input column  172  is  3 . Accordingly, the output data  174  for the sum operation includes the data values  11 ,  7 , and  3 . 
       FIG.  8    illustrates an operation of the batch buffer  152  of the pooling unit  106 , according to one embodiment. The batch buffer  152  receives the data values  174  from the column calculator  150 . The batch buffer  152  stores the data values  174  in rows and columns. The batch buffer  152  receives the data values  174  via a column demultiplexer  176 . The batch buffer is composed of multiple rows and columns. The maximum number of rows correspond to the maximum batch size the unit is designed to support. For instance if the maximum batch size is 8, the number of rows is 8, thus the unit supports tensors with batch sizes ranging from 1 to 8. In this specific example the tensor batch size is 3, thus 3 rows are occupied even though the actual number of rows could be larger. Similarly the unit can be designed with a number of columns corresponding to the maximum pooling window width dimension expected to be supported. In this figure the number of columns is 3 thus the unit can support pooling window widths of 1, 2 or 3. 
     The column demultiplexer  176  receives data values  174  and slots them in the desired batch buffer columns, depending on the batch index associated with the incoming columns. In this example, the data value OP( 1   a,    1   b ,  1   c ) corresponds to batch index 0 (batch size=3, thus indices range from 0, 1, 2), thus is placed in the first batch buffer row. Similarly the next data value OP( 2   a , 2   b , 2   c ) corresponds to batch index  1 , thus is placed in the second batch buffer row and so o, while the data value OP( 4   a , 4   b , 4   c ) corresponds to batch index 0 thus is placed in batch buffer row 0, but column index 1 since it&#39;s the result of the second column along the width dimension of the feature tensor. Thus, in the example of  FIG.  8   , OP( 1   a,    1   b ,  1   c ) corresponds to the data value  174  generated by performing the selected operation of the column calculator on the data column  172  including corresponding to indices  1   a ,  1   b , and  1   c  from the feature tensor  128  or the crops feature tensor  168 . The column demultiplexer  176  outputs the various data values in  174  in a selected manner in the rows and columns of the batch buffer  152 . 
       FIG.  9    illustrates an operation of the batch buffer  152  and the row calculator  154  of the pooling unit  106 , according to one embodiment. The batch buffer  152  outputs the rows of data values  174  to the row multiplexer  178 . The row calculator  154  receives rows of data from the row multiplexer  178 . 
     In one embodiment, the row calculator  154  performs an operation on each row from the batch buffer  152 . The row calculator  154  outputs, for each row, a data value corresponding to the operation performed on the row. The type of operation to be performed by the row calculator  154  is stored in the configuration registers  164 . The operations can include a maximum operation, a minimum operation, or a sum operation. 
       FIG.  10    illustrates a pooling operation performed by the pooling unit  106 , according to one embodiment. The configuration registers  164  determine the size of a pooling window for each pooling operation. The pooling window corresponds to a selected portion of the cropped feature tensor  168 . The size of the pooling window determines, in part, the magnitude of the reduction in size between the input of the pooling unit  106  and the output of the pooling unit  106 . 
     In the example of  FIG.  10   , the pooling window is 3×3. If the height and width of the cropped feature tensor  168  is 9×9, the selected pooling window is 3×3, and the stride is 3 (described in more detail below) then for each nonoverlapping 3×3 window of a single depth slice of the cropped feature tensor  168 , a single data value will be generated by the pooling operation. This corresponds to nine data values for each 9×9 slice from the cropped feature tensor  168 . 
     A 3×3 sub-tensor is selected from the cropped tensor  168  in the example of  FIG.  10   . The 3×3 sub-tensor is passed to the column calculator  150 . The column calculator  150  is configured to provide, for each column, the sum of the data values in that column. Accordingly, the output of the column calculator is the data values 12, 15, 18. The row calculator  154  is also configured to perform a summing operation. Accordingly, the row calculator  154  generates the data value 45 which is the sum of 12, 15, and 18. 
     In one example, the selected pooling operation is an average rather than a sum. In this case, the column calculator  150  and the row calculator  150  for each generate a sum as shown in  FIG.  10   . The total sum of 45 is then provided to the average multiplier stage  158 . The average multiplier stage  158  performs an averaging operation on the sum from the row calculator  150 . The output of the average multiplier stage is the value of 5. 5 is the average of the values in the 3×3 pooling window. This operation is performed for all of the pooling windows until an average value is generated for each pooling window. A reduced feature tensor has been generated by the pooling unit  106  including each of the values generated for each of the pooling windows. 
     In one embodiment, the average multiplier stage  158  includes a multiplier  180  and an adjuster unit  182 . The effect of the average multiplier stage  158  is to divide the value provided by the row calculator  154  by the number of data values in the pooling window. In the example of  FIG.  10   , the effect of the average multiplier stage  158  is to divide the output of the row calculator  154  by 9. However, division operations are highly expensive in terms of area in computational power. Accordingly, the multiplier converts the fraction 1/9 to its fixed point Q15 form of 3641. The multiplier then multiplies 3641 by 45, resulting in a value of 163845. This number is provided to the adjuster unit. The adjustor unit  182  downshifts and rounds and saturates (if configured so) the value down to the value of 5, which is the average of the values in the pooling window. In this way, the average multiplier stage  158  can calculate the average of the pooling window. 
     The multiplier stage  158  consists of a configurable downshift or in support for truncating, rounding, and saturating the downshift in value based on values specified in the pooling unit configuration register  164 . Various rounding modes such as rounds to the nearest, and round away from zero, round to nearest even, can be supported. The output can be saturated, if required, by enabling saturation via the configuration registers  164 . If saturation is not enabled, the output is simply truncated to output data with. Returning to  FIG.  4   , the stride manager  160  is responsible to gate the inputs and only allows those sample values to pass based on specified horizontal and vertical strides in the pooling. One embodiment could use 2 counters counting up to the values of the horizontal and vertical strides respectively. The counters are triggered on each arriving input while the output is gated unless the counters are both 0, thus allowing only those values to be output that respect the striding requirements. 
     In one embodiment, the pooling unit  106  also supports global pooling. In particular, the pooling unit  106  includes a global pooling unit  166 . The global pooling unit offers a dedicated data path to perform global pooling on arbitrary sized tensors. Global pooling is different from windowed pooling in the sense that the pooling window encompasses the entire width and height of the input feature tensor. Global pooling bypasses the line buffer  146 , the padding control  148 , the column calculator  150 , the row calculator  154 , and the batch buffer  152  which can be clock gated, thus saving runtime power. The global pooling unit  166  is also batch aware. 
     The pooling unit  106  also supports unpooling. In particular, the unpooling block  163  enables unpooling operations. The unpooling operation augments max and min pooling in convolutional neural network topologies with applications in semantic segmentation among others. In max unpooling, the unpooling block  163  records, for each pooling window, the position in the pooling window from which the max value was drawn. The feature tensor  128  or the cropped feature tensor  168  can be partially regenerated by the unpooling operation. In particular, the max values are placed back in their respective data fields from the feature tensor  128  or the cropped feature tensor  168 . The other data fields can be populated with zeros. The unpooling block  163  can do the same thing for minimum pooling, except that the minimum values are placed back in their data fields and the other data fields are populated with zeros. 
       FIG.  11    is flow diagram of a method  1100  for operating a convolutional neural network, according to one embodiment. At  1102 , the method  1100  includes receiving, in a pooling unit of a convolutional neural network, a feature tensor. At  1104 , the method  1100  includes generating a cropped feature tensor including a plurality of data values by cropping the feature tensor with a cropper of the pooling unit. At  1106 , the method  1100  includes passing the data values of the cropped feature tensor to a single ported line buffer of the pooling unit. At  1108 , the method  1100  includes generating pooled feature data by performing column and row pooling calculations on the data values from the line buffer. At  1110 , the method  1100  includes outputting the pooled feature data to a convolution layer of the convolutional neural network. 
     While the method  1100  describes outputting the pooled feature data to a convolution layer, the pooled feature data can be output to layers, processes, components, or modules other than a convolution layer without departing from the scope of the present disclosure. Other variations to the method  1100  can be made without departing from the scope of the present disclosure. 
       FIG.  12    is flow diagram of a method  1200  for operating a convolutional neural network, according to one embodiment. At  1202 , the method  1200  includes receiving, in a pooling unit of a convolutional neural network, a feature tensor. At  1204 , the method  1200  includes storing, in a configuration register of the pooling unit, pooling window size data. At  1206 , the method  1200  includes generating, with the pooling unit, a plurality of pooling windows from the feature tensor in accordance with the pooling window size data. At  1208 , the method  1200  includes generating pooled feature data by performing column and row pooling calculations on the data values from the pooling windows. At  1210 , the method  1200  includes outputting the pooled feature data to a convolution layer of the convolutional neural network. 
     While the method  1200  describes outputting the pooled feature data to a convolution layer, the pooled feature data can be output to layers, processes, components, or modules other than a convolution layer without departing from the scope of the present disclosure. Other variations to the method  1200  can be made without departing from the scope of the present disclosure. 
     Further details related to electronic devices implementing convolutional neural networks can be found in U.S. Patent Application Publication 2019/0266479, filed Feb. 20, 2019, in U.S. Patent Application Publication No. 2019/0266485, filed Feb. 20, 2019, and in U.S. Patent Application Publication No. 2019/0266784, filed Feb. 20, 2019, each of which are incorporated herein by reference in their entireties. 
     The various embodiments described above can be combined to provide further embodiments. These and other changes can be made to the embodiments in light of the above-detailed description. In general, in the following claims, the terms used should not be construed to limit the claims to the specific embodiments disclosed in the specification and the claims, but should be construed to include all possible embodiments along with the full scope of equivalents to which such claims are entitled. Accordingly, the claims are not limited by the disclosure.