WO2023120829A1 - 어레이 풀링 방법 및 이를 위한 장치 - Google Patents

어레이 풀링 방법 및 이를 위한 장치 Download PDF

Info

Publication number
WO2023120829A1
WO2023120829A1 PCT/KR2022/007383 KR2022007383W WO2023120829A1 WO 2023120829 A1 WO2023120829 A1 WO 2023120829A1 KR 2022007383 W KR2022007383 W KR 2022007383W WO 2023120829 A1 WO2023120829 A1 WO 2023120829A1
Authority
WO
WIPO (PCT)
Prior art keywords
pooling
index
buffer
buffers
window
Prior art date
Application number
PCT/KR2022/007383
Other languages
English (en)
French (fr)
Inventor
전지현
Original Assignee
오픈엣지테크놀로지 주식회사
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by 오픈엣지테크놀로지 주식회사 filed Critical 오픈엣지테크놀로지 주식회사
Publication of WO2023120829A1 publication Critical patent/WO2023120829A1/ko

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/04—Architecture, e.g. interconnection topology
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/06—Physical realisation, i.e. hardware implementation of neural networks, neurons or parts of neurons
    • G06N3/063—Physical realisation, i.e. hardware implementation of neural networks, neurons or parts of neurons using electronic means
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/08—Learning methods

Definitions

  • the present invention relates to a method for performing pooling in a computing device and a hardware accelerator to which the method is applied.
  • a CNN performs a plurality of operation steps including a pooling operation.
  • US registered patent US10713816 proposes an object detection method using a deep CNN pooling layer as a feature.
  • FIG. 1 illustrates a computational structure of a CNN according to an embodiment. It will be described with reference to FIG. 1 below.
  • convolution layers 52 may be generated by performing a convolution operation using a plurality of kernels on the input image data 51 stored in the internal memory. Generating the convolution layers 52 may include performing a nonlinear operation (eg, ReLU, Sigmoid, or tanH) on a plurality of feature maps obtained as a result of performing the convolution operation.
  • a nonlinear operation eg, ReLU, Sigmoid, or tanH
  • pooling of the convolutional layers 52 may be performed to generate pooling layers 53 .
  • Each convolutional layer 52 may include data that can be expressed in the form of an M*N matrix.
  • a pooling window which is a window having a smaller dimension than the convolution layer 52, may be defined to perform pooling.
  • the pooling window may have sizes of Mp and Np in the row and column directions, respectively.
  • the pooling is an operation of generating a smaller number of data, for example, one data, from Mp*Np data selected by overlapping the pooling window on the convolution layer.
  • MAX pooling is an operation of selecting and outputting one of the largest values among the Mp*Np pieces of data.
  • average pooling is an operation of outputting an average value of the Mp*Np pieces of data.
  • Other pooling rules may be defined. The number of cases in which the pooling window may overlap the convolutional layer varies. According to embodiments, rules for moving the pooling window on the convolution layer may be restricted.
  • the row direction stride of the pooling operation is referred to as SM
  • the pooling window is set in the column direction of the convolution layer
  • the stride in the column direction of the pooling operation may be referred to as SN (SM and SN are natural numbers).
  • SN the stride in the column direction of the pooling operation
  • the size of the pooling layer output as a result of the pooling operation may decrease.
  • the specific concept of the pooling operation is well presented in the prior art describing CNNs.
  • an array to be input to the neural network 54 may be generated by performing flattening on the pooling layers 53 .
  • the array can then be input to the neural network 54 to generate an output from the neural network 54 .
  • FIG. 1 shows one embodiment of a CNN
  • various other examples of implementing CNNs exist.
  • the pooling operation is used for the implementation of CNN in FIG. 1, the pooling operation may be used in other computing technology fields other than CNN.
  • the amount of computation of the pooling operation tends to increase as the size of the pooling window increases, and tends to increase as the size of the stride decreases. Also, the smaller the size of the stride, the higher the tendency for the same operation to be repeated during the pooling operation.
  • An object of the present invention is to provide a pooling method that reduces the amount of computation for pooling a one-dimensional array.
  • a method of pooling an input array 10 with a pooling window 20 for pooling an even number of elements may be provided.
  • n-2; k is an integer); and storing, by the computing device, a result value obtained by pooling the values of indices 0 to n ⁇ 1 among the first set of buffers in a buffer having an index j among the pooling buffers 60.
  • the method further includes, before the step of storing in the internal memory, the computing device reading the elements of index k to index k+2n-1 from the input array and storing them in the internal memory 30. can do.
  • the computing device determines the values of index k to index k+2n-2 of the input array.
  • a step of deleting may be further included.
  • the computing device stores a result value obtained by pooling a pair consisting of an element with an index k+2n-1 and an index k+2n in a buffer having an index n-1 among buffers of the second set. storing; and pooling, by the computing device, the values of indices 0 to n ⁇ 1 among the second set of buffers and storing them in a buffer having index j+1 among the pooling buffers.
  • the computing device reads the element of index k+2n from the input array, A step of storing in an internal memory may be further included.
  • the computing device determines the index k+2n ⁇ 1 of the input array.
  • a step of deleting the value may be further included.
  • the value of the buffer having index 0 among the buffers of the first set is a value obtained by pooling a pair consisting of elements of index k+2n and index k+2n+1 in the input array. updating; and pooling the values of indices 0 to n ⁇ 1 among the first set of buffers and storing them in a buffer having index j+2 among the pooling buffers.
  • the method further includes reading an element of index k+2n+1 from the input array and storing the element in the internal memory between the step of storing in the buffer having index j+1 and the step of updating. can do.
  • the method may further include deleting the value of index k+2n from the input array between the updating step and the step of storing the value in the buffer having index j+2.
  • FIG. 1 illustrates a computational structure of a CNN according to an embodiment.
  • FIG. 2 shows an example of a configuration of hardware to which an operation method provided according to an embodiment of the present invention can be applied.
  • FIG. 3 illustrates an example input array to explain a pooling method provided according to an embodiment of the present invention.
  • 4A to 4D show a method of pooling an input array by a pooling window according to an embodiment of the present invention.
  • 5A to 5D show a method of pooling an input array by a pooling window according to another embodiment of the present invention.
  • 6A to 6D show a method of pooling an input array by a pooling window according to another embodiment of the present invention.
  • FIG. 7A to 7D illustrate a method of pooling an input array by a pooling window according to another embodiment of the present invention.
  • 8A to 8C are flowcharts illustrating a method of performing pooling according to an embodiment of the present invention.
  • FIG. 2 shows an example of a configuration of hardware to which an operation method provided according to an embodiment of the present invention can be applied.
  • FIG 2 illustrates the main structure of some of the computing devices in which the calculation method provided according to an embodiment of the present invention is implemented in hardware.
  • the computing device 1 includes a dynamic random access memory (DRAM) 130, a hardware accelerator 110, a bus 700 connecting the DRAM 130 and the hardware accelerator 110, and other devices connected to the bus 700.
  • DRAM dynamic random access memory
  • the DRAM 130 may be referred to as a memory 130 .
  • the computing device 1 may further include a power supply unit, a communication unit, a user interface, a storage unit 170, and peripheral units not shown.
  • the bus 700 may be shared by the hardware accelerator 110, other hardware 99, and the main processor 160.
  • the hardware accelerator 110 includes a direct memory access part (DMA) 20, a control unit 114, an internal memory 30, an input buffer 650, a data operation unit 610, and an output buffer 640 can do.
  • DMA direct memory access part
  • Some or all of data temporarily stored in the internal memory 30 may be provided from the DRAM 130 through the bus 700 .
  • the control unit 114 and the DMA unit 112 may control the internal memory 30 and the DRAM 130.
  • Data stored in the internal memory 30 may be provided to the data calculator 610 through the input buffer 650 .
  • Output values generated by the operation of the data calculator 610 may be stored in the internal memory 30 via the output buffer 640 .
  • the output values stored in the internal memory 30 may be written to the DRAM 130 under the control of the control unit 114 and the DMA unit 112 .
  • the control unit 114 may collectively control the operations of the DMA unit 112, the internal memory 30, and the data operation unit 610.
  • the data calculator 610 may perform a first calculation function during a first time period and a second calculation function during a second time period.
  • one data calculation unit 610 is presented in the hardware accelerator 110 .
  • a plurality of data calculation units 610 shown in FIG. 2 may be provided in the hardware accelerator 110 to perform operations requested by the control unit 114 in parallel. there is.
  • the data operation unit 610 may sequentially output the output data according to a given order according to time rather than outputting them all at once.
  • FIG. 3 illustrates an example input array to explain a pooling method provided according to an embodiment of the present invention.
  • the input array 10 may be stored in the DRAM 130 . Although the input array 10 is illustrated in FIG. 3 as being composed of a total of 13 elements, this is for convenience of description and the number of elements included in the input array 10 may have a different value.
  • the control unit 114 or the DMA unit 112 may read all or part of the input array 10 from the DRAM 130 and store it in the internal memory 30 .
  • the controller 114 may store all or part of the input array 10 stored in the internal memory 30 in the input buffer 650 .
  • the pooling method described below relates to a method of pooling the input array 10 using a pooling window 20 having a predetermined size.
  • eight elements are included in the pooling window 20 .
  • n 4.
  • the pooling illustrated in FIG. 3 may be, for example, MAX pooling.
  • the largest value among the values of the eight elements selected by the pooling window 20 may be output as a pooling result.
  • the pooling of the present invention is not limited to the MAX pooling, and various possible pooling methods may be applied.
  • the index k shown in FIG. 3 is introduced for convenience of explanation, and may be an arbitrary integer.
  • the index k represents the first element of the input array 10 .
  • FIGS. 4A to 4D are collectively referred to as FIG. 4 .
  • FIG. 4 illustrates a method of pooling an input array by a pooling window according to an embodiment of the present invention.
  • 4A shows the state of the internal memory in which a part of the input array selected by the pooling window is stored.
  • n 4.
  • s of 'pooling window (20[+s])' in this specification means a pooling window in a state where the pooling window 20 moves by the stride s from the initial position (s is an integer).
  • the pooling window 20[+0] selects values of index k+0 to index k+2n ⁇ 1 from the input array 10 .
  • the pooling window 20[+s] selects values of index k+s to index k+2n-1+s from the input array 10 .
  • 2n elements selected by the pooling window 20[+0] are represented by index k to index k+2n ⁇ 1 of the internal memory 30.
  • a 2n size space may be allocated in the internal memory 30 to store the 2n elements selected by the pooling window 20[+0]. This assignment may be performed by the control unit 114 .
  • 4B illustrates a process of storing elements selected by the pooling window in two different sets of buffers according to an embodiment of the present invention.
  • the different sets of buffers may be a first set of buffers 40 and a second set of buffers 50 .
  • the first set of buffers 40 and the second set of buffers 50 may be part of the input buffer 650 .
  • step S100 the controller 114 may move the elements selected by the pulling window 20[+0] to the internal memory 30.
  • the controller 114 may obtain an address within the DRAM 130 where the input array 10 is stored. After that, the control unit can read the elements selected by the pulling window 20 [+0] from the DRAM 130 and move them to a space prepared in the internal memory 30 . Elements selected by the pooling window 20[+0] may be, for example, consecutive 2n elements including the smallest index among the input array 10 .
  • a pair of elements consisting of elements of index k+4 and index k+5 among elements selected by the pooling window 20[+0] is selected.
  • '2' which is the result of pooling, may be stored.
  • the values of index 0 to index 3 (ie, index n-1) of the first set of buffers 40 are determined by the elements selected by the pooling window 20[+0]. can be determined
  • step S120 the control unit 114 performs pooling on a pair consisting of the elements of index k+2q+1 and index k+2q+2, and the pooling results are stored in the second set of buffers 50.
  • '8' which is the result of pooling, may be stored.
  • a pair of elements consisting of elements of index k+5 and index k+6 among elements selected by the pooling window 20[+0] is selected.
  • '3' which is the result of pooling, may be stored.
  • the values of index 0 to index 2 (ie, index n-2) of the second set of buffers 50 are determined by the elements selected by the pooling window 20[+0]. can be determined
  • the data operation unit 610 may perform minimum pooling, which is pooling on a pair consisting of the elements of index k+2q+1 and index k+2q+2.
  • the control unit 114 may control the function of the data operation unit 610 so that the data operation unit 610 executes the minimum pooling.
  • steps S110 and S120 may be changed.
  • 4C illustrates a process of deleting some of the elements used for pooling among the elements selected by the pooling window 20[+0] according to an embodiment of the present invention.
  • step S130 the control unit 114 may delete the values of index k to index k+2n-2 among the elements selected by the pooling window 20[+0] (character ' in FIG. 4C). marked with X'). That is, among the elements selected by the pooling window 20[+0], values other than the value of the last index k+2n-1 may be deleted.
  • step S130 may not necessarily be executed. However, when step S130 is executed, some of the space of the internal memory 30 may be allocated for other tasks.
  • 4D illustrates a process of storing a pooled result in a pooling buffer according to an embodiment of the present invention.
  • step S140 the control unit 114 performs pooling on the values of indices 0 to n-1 among the first set of buffers 40, and pools the result of the pooling among the pooling buffers 60. It can be stored in the buffer with index j. For example, as shown in FIG. 4D, pooling is performed on the values of indexes 0 to 3 of the first set of buffers 40, and '8', the result of the pooling, is selected as the index of the pooling buffer 60. It can be stored in a buffer with j.
  • the pulling buffer 60 may be a buffer different from the first set of buffers 40 and the second set of buffers 50, and may be included in the internal memory 30 or the input buffer 60. It may be included in the buffer 650.
  • the letter j shown in FIG. 4D is introduced for convenience of description, and may be an arbitrary integer.
  • step S140 the pooling process for the values selected by the pooling window 20[+0] is completed.
  • data may be newly selected from the input array 10 by moving the pooling window 20[+0] by a predetermined stride, and pooling may be performed on the newly selected data.
  • the predetermined stride may have a value of '1'.
  • a pooling window moved by a stride of 1 in a direction in which the index k increases from the pooling window 20[+0] shown in FIG. 4B may be expressed as a pooling window 20[+1].
  • pooling can be performed using only some of the 2n pieces of data newly selected from the input array 10 by the pooling window 20[+1] whose position is moved. The method will be described below.
  • Data selected by the pulling window 20[+1] shifted by 1 stride are index k+1 to index k+8 of the input array 10 . That is, index k+1 to index k+2n of the input array 10 may be selected by the pooling window 20[+1].
  • each value of the index k+1 to index k+6 of the input array 10 may not be used again. That is, each value of index k+1 to index k+2n-2 of the input array 10 may not be used again. Instead, data already stored in the first set of buffers 40 and the second set of buffers 50 may be used instead, which will be separately described later.
  • only the value of the index k+8 of the input array 10 may be read from the DRAM 130 and written to the internal memory 30 . That is, only the index k+2n of the input array 10 can be read and written to the internal memory 30 . In this case, the value of the index k+8 of the input array 10 may be provided from a place other than the DRAM 130 .
  • FIGS. 5A to 5D are collectively referred to as FIG. 5 .
  • FIG. 5 illustrates a method of pooling an input array by a pooling window according to another embodiment of the present invention.
  • 5A shows a state in which the value of the index k+8 of the input array 10 is stored in the internal memory according to an embodiment of the present invention.
  • 5B illustrates a process of determining a value of a buffer having an index n ⁇ 1 among the second set of buffers.
  • step S150 the control unit 114 performs pooling on a pair consisting of an element of index k+2n ⁇ 1 and index k+2n, and the pooling result value is stored in the second set of buffers 50. It can be stored in a buffer with index n-1. That is, in the example of FIG. 5B, pooling is performed on a pair consisting of an element of index k+7 and index k+8, and '9', the result of the pooling, is assigned to index 3 of the second set of buffers 50. It can be stored in a buffer with Now, the values of the total n indexes of the second set of buffers 50 are all determined.
  • 5C illustrates a process of deleting some of the elements used for pooling among the elements selected by the pooling window (20[+1]) shifted by 1 stride according to an embodiment of the present invention.
  • step S160 may not necessarily be executed. However, if step S160 is executed, some of the space of the internal memory 30 may be allocated for other tasks.
  • 5D illustrates a process of storing a pooled result in a pooling buffer according to an embodiment of the present invention.
  • step S170 the control unit 114 performs pooling on the values of indices 0 to n-1 among the second set of buffers 50, and pools the resultant values in the pooling buffer 60. It can be stored in the buffer with index j+1. For example, as shown in FIG. 5D, pooling is performed on the values of indexes 0 to 3 of the second set of buffers 50, and '9', the result of the pooling, is selected as the index of the pooling buffer 60. It can be stored in a buffer with j+1.
  • step S170 the pooling process for the values selected by the pooling window 20[+1] is completed.
  • data is newly selected from the input array 10 by moving the pooling window 20[+1] further by a stride of 1, and pooling of the newly selected data may be executed.
  • a pooling window obtained by further moving the pooling window 20[+1] by a stride of 1 may be referred to as a pulley window 20[+2].
  • FIGS. 6A to 6D are collectively referred to as FIG. 6 .
  • FIG. 6 illustrates a method of pooling an input array by a pooling window according to another embodiment of the present invention.
  • FIG. 6A shows a state in which the value of the index k+9 of the input array 10 is stored in the internal memory according to an embodiment of the present invention.
  • 6B illustrates a process of updating a value of a buffer having index 0 among the first set of buffers.
  • the values of the buffers having index 0 to index n-1 among the buffers 40 of the first set are all determined.
  • the index k+0 and index k+1 of the input array 10 value is no longer needed.
  • the value of index 0 in the first set of buffers 40 is also unnecessary.
  • step S180 the control unit 114 sets the value of the buffer having index 0 among the first set of buffers 40 to index k+2n and index k+ of the input array 10.
  • a pair of 2n+1 values can be updated with a pooled value.
  • pooling for the pooling window 20[+2] may be completed by pooling the first set of buffers 40 .
  • 6C illustrates a process of deleting some of the elements used for pooling among the elements selected by the pooling window 20[+2] according to an embodiment of the present invention.
  • step S190 may not necessarily be executed. However, when step S190 is executed, some of the space of the internal memory 30 can be allocated for other tasks.
  • 6D illustrates a process of storing a pooled result in a pooling buffer according to an embodiment of the present invention.
  • step S200 the control unit 114 performs pooling on the values of index 0 to n-1 among the first set of buffers 40, and pools the resultant values in the pooling buffer 60. It can be stored in the buffer with index j+2. For example, as shown in FIG. 6D, pooling is performed on the values of indexes 0 to 3 of the first set of buffers 40, and '10', the result of the pooling, is selected as the index of the pooling buffer 60. It can be stored in a buffer with j+2.
  • step S200 the pooling process for the values selected by the pooling window 20[+2] is completed.
  • data is newly selected from the input array 10 by further moving the pooling window 20[+2] by a stride of 1, and pooling of the newly selected data may be performed.
  • FIGS. 7A to 7D are collectively referred to as FIG. 7 .
  • FIG. 7 illustrates a method of pooling an input array by a pooling window according to an embodiment of the present invention.
  • FIG. 7A shows a state in which the value of the index k+11 of the input array 10 is stored in the internal memory according to an embodiment of the present invention.
  • 7B illustrates a process of determining a value of a buffer having index 0 among the second set of buffers.
  • FIG. 7C illustrates a process of deleting some of the elements used for pooling among the elements selected by the pooling window 20[+3] according to an embodiment of the present invention.
  • FIG. 7D illustrates a process of storing a pooled result in a pooling buffer according to an embodiment of the present invention.
  • the control unit 114 performs pooling on the values of index 0 to n-1 among the second set of buffers 50, and the pooling result value has index j+3 among the pooling buffer 60.
  • Embodiments of the present invention described with reference to FIGS. 4 to 7 can be summarized as follows.
  • the method described in FIG. 4 shows a method of performing initial pulling from the input array 10 using the pulling window 20 .
  • the method described in FIG. 5 shows a method of executing pooling using a pooling window 20 [+1] moved from the pooling window 20 by a stride of 1.
  • the method described in FIG. 6 shows a method of executing pooling using a pooling window (20[+2]) moved by a stride of 2 from the pooling window (20).
  • the method described in FIG. 7 shows a method of executing pooling using a pooling window (20[+3]) moved by a stride of 3 from the pooling window (20).
  • the process shown in FIG. 4 may be referred to as a starting process P0.
  • the process shown in FIG. 5 may be referred to as an odd-stride process P1.
  • the process shown in FIG. 6 may be referred to as an even-stride process P2.
  • the odd-stride process P1 and the even-stride process P2 are alternately executed (P0 ⁇ P1 ⁇ P2 ⁇ P1 ⁇ P2 ⁇ P1 ⁇ P2 ⁇ ...), pooling using the pooling window 20 for the input array 10 can be completed.
  • the completed pooling value is stored in the pooling buffer 60 and can be used in other necessary processes.
  • FIGS. 8A, 8B, and 8C are collectively referred to as FIG. 8 .
  • FIG. 8A is a flowchart illustrating a pooling method provided according to an embodiment of the present invention.
  • 8B is a flowchart illustrating a pooling method provided according to another embodiment of the present invention.
  • 8C is a flowchart illustrating a pooling method provided according to another embodiment of the present invention.
  • FIGS. 8A, 8B, and 8C may be referred to as a starting pooling process (PO), an odd-stride pooling process (P1), and an even-stride pooling process (P2), respectively.
  • PO starting pooling process
  • P1 odd-stride pooling process
  • P2 even-stride pooling process
  • the method presented in FIG. 8A may include the following steps.
  • step S100 the controller 114 may move the elements selected by the pulling window 20[+0] to the internal memory 30.
  • control unit 114 may delete the values of index k to index k+2n-2 among the elements selected by the pooling window 20[+0] (character ' in FIG. 4C). marked with X').
  • step S140 the control unit 114 performs pooling on the values of indices 0 to n-1 among the first set of buffers 40, and pools the result of the pooling among the pooling buffers 60. It can be stored in the buffer with index j.
  • the method presented in FIG. 8B may include the following steps.
  • step S150 the control unit 114 performs pooling on a pair consisting of an element of index k+2n ⁇ 1 and index k+2n, and the pooling result value is stored in the second set of buffers 50. It can be stored in a buffer with index n-1.
  • step S170 the control unit 114 performs pooling on the values of indices 0 to n-1 among the second set of buffers 50, and pools the resultant values in the pooling buffer 60. It can be stored in the buffer with index j+1.
  • the method presented in FIG. 8C may include the following steps.
  • step S180 the control unit 114 sets the value of the buffer having index 0 among the first set of buffers 40 to index k+2n and index k+2n+1 of the input array 10.
  • a pair of values of can be updated with a pooled value.
  • step S200 the control unit 114 performs pooling on the values of index 0 to n-1 among the first set of buffers 40, and pools the resultant values in the pooling buffer 60. It can be stored in the buffer with index j+2.
  • the present invention is an edge application scalable on-device AI computing in the SW computing industry source technology development, which is a research project supported by Open Edge Technology Co., Ltd. (the project performing organization) and the National Research Foundation of Korea Information and Communication Planning and Evaluation Institute. It was developed in the process of carrying out the research task of developing a lightweight model framework for (task identification number 2021000105, task number 2021-0-00105, research period 2021.04.01 ⁇ 2024.12.31).

Landscapes

  • Engineering & Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • Theoretical Computer Science (AREA)
  • Health & Medical Sciences (AREA)
  • Life Sciences & Earth Sciences (AREA)
  • Biomedical Technology (AREA)
  • Biophysics (AREA)
  • General Health & Medical Sciences (AREA)
  • General Physics & Mathematics (AREA)
  • Evolutionary Computation (AREA)
  • Computational Linguistics (AREA)
  • Molecular Biology (AREA)
  • Computing Systems (AREA)
  • General Engineering & Computer Science (AREA)
  • Data Mining & Analysis (AREA)
  • Mathematical Physics (AREA)
  • Software Systems (AREA)
  • Artificial Intelligence (AREA)
  • Neurology (AREA)
  • Image Input (AREA)
  • Complex Calculations (AREA)

Abstract

짝수 개의 요소들을 풀링하는 풀링 윈도우로 입력 어레이를 풀링하는 방법을 공개한다. 인덱스 k+2p 및 인덱스 k+2p+1 의 엘리먼트로 이루어지는 쌍에 대하여 풀링한 결과값을 제1세트의 버퍼들 중 인덱스 p를 갖는 버퍼에 저장하고, 그리고 인덱스 k+2q+1 및 인덱스 k+2q+2 의 엘리먼트로 이루어지는 쌍에 대하여 풀링한 결과값을 제2세트의 버퍼들 중 인덱스 q를 갖는 버퍼에 저장하는 단계, 및 상기 제1세트의 버퍼들 중 인덱스 0 내지 n-1의 값들에 대하여 풀링한 결과값을 풀링버퍼 중 인덱스 j을 갖는 버퍼에 저장하는 단계를 포함한다.

Description

어레이 풀링 방법 및 이를 위한 장치
본 발명은 컴퓨팅 장치에서 풀링을 수행하는 방법 및 이 방법이 적용된 하드웨어 가속기에 관한 것이다.
CNN은 풀링 연산을 포함하는 복수 개의 연산단계를 수행한다. 미국등록특허 US10713816에는 심층 CNN 풀링 레이어를 특징으로서 이용하는 물체검출 방법이 제시되어 있다.
도 1은 일 실시예에 따른 CNN의 연산구조를 나타낸 것이다. 이하 도 1을 참조하여 설명한다.
우선, 내부메모리에 저장된 입력 이미지 데이터(51)에 복수 개의 커널들을 이용한 콘볼루션 연산을 수행하여 콘볼루션 레이어들(52)을 생성할 수 있다. 콘볼루션 레이어들(52)을 생성하는 단계는 상기 콘볼루션 연산을 수행한 결과 얻은 복수 개의 피쳐 맵들에 대하여 비선형 연산(ex: ReLU, Sigmoid, 또는, tanH)을 수행하는 단계를 포함할 수 있다.
그 다음 콘볼루션 레이어들(52)에 대한 풀링을 수행하여 풀링 레이어들(53)을 생성할 수 있다. 각각의 콘볼루션 레이어(52)는 M*N 행렬 형태로 표현될 수 있는 데이터를 포함할 수 있다. 이때, 풀링을 수행하기 위하여 상기 콘볼루션 레이어(52)보다 작은 디멘젼을 갖는 윈도우인 풀링 윈도우가 정의될 수 있다. 풀링 윈도우는 행 및 열 방향에 대하여 각각 Mp 및 Np의 크기를 가질 수 있다. 풀링 윈도우의 크기는 콘볼루션 레이어의 크기보다 작을 수 있다(M>=Mp 이고 N>Np, 또는 M>Mp 이고 N>=Np). 상기 풀링은 상기 콘볼루션 레이어에 상기 풀링 윈도우를 겹쳐 선택하는 Mp*Np 개의 데이터들로부터 이 보다 더 작은 개수의 데이터, 예컨대 1개의 데이터를 생성하는 연산이다. 예컨대 MAX 풀링은 상기 Mp*Np 개의 데이터들 중에서 가장 큰 값 1개를 선택하여 출력하는 연산이다. 예컨대 average 풀링은 상기 Mp*Np 개의 데이터들의 평균값을 출력하는 연산이다. 그 밖에 다른 규칙을 따르는 풀링이 정의될 수 있다. 상기 콘볼루션 레이어에 상기 풀링 윈도우를 겹칠 수 있는 경우의 수는 다양하다. 실시예에 따라 상기 콘볼루션 레이어 상에서 상기 풀링 윈도우를 이동시키는 규칙을 제한할 수 있다. 예컨대, 상기 풀링 윈도우를 상기 콘볼루션 레이어의 행 방향을 따라 SM 칸 씩 건너뛰어서 이동하도록 제한 경우 상기 풀링 연산의 행 방향 Stride는 SM인 것으로 지칭하고, 상기 풀링 윈도우를 상기 콘볼루션 레이어의 열 방향을 따라 SN 칸 씩 건너뛰어서 이동하도록 제한 경우 상기 풀링 연산의 열 방향 Stride는 SN인 것으로 지칭할 수 있다(SM 및 SN 는 자연수). Stride 의 크기가 커질수록, 풀링 연산의 결과로서 출력되는 풀링 레이어의 크기는 더 작아질 수 있다. 상술한 설명 외에도, 풀링 연산에 대한 구체적인 개념은 CNN을 설명하는 선행기술에 잘 제시되어 있다.
그 다음, 상기 풀링 레이어들(53)에 대한 플래트닝(flattening)을 수행하여 신경망(54)에 입력할 어레이를 생성할 수 있다.
그 다음, 상기 어레이를 상기 신경망(54)에 입력하여 상기 신경망(54)으로부터 출력을 생성할 수 있다.
도 1에서는 CNN의 일 실시예를 나타내었지만, CNN을 구현하는 다양한 다른 예가 존재한다. 또한, 도 1에서 풀링 연산이 CNN의 구현을 위해 이용되었지만, 풀링 연산은 CNN이 아닌 다른 컴퓨팅 기술분야에서도 사용될 수 있다.
풀링 연산의 연산량은 풀링 윈도우의 크기가 커지면 커지는 경향이 있고, Stride의 크기가 작을수록 키지는 경향이 있다. 또한 Stride의 크기가 작을수록 풀링 연산을 수행하는 과정에서 동일한 연산이 반복되는 경향이 높아진다.
본 발명에서는 1차원 어레이에 대한 풀링 연산을 위한 연산량을 감소시키는 풀링 방법을 제공하고자 한다.
본 발명의 일 관점에 따라 짝수 개의 요소들을 풀링하는 풀링 윈도우(20)로 입력 어레이(10)를 풀링하는 방법이 제공될 수 있다. 상기 방법은, 컴퓨팅 장치가, 인덱스 k+2p 및 인덱스 k+2p+1 의 엘리먼트로 이루어지는 쌍에 대하여 풀링한 결과값을 제1세트의 버퍼들(40) 중 인덱스 p를 갖는 버퍼에 저장하고, 그리고 인덱스 k+2q+1 및 인덱스 k+2q+2 의 엘리먼트로 이루어지는 쌍에 대하여 풀링한 결과값을 제2세트의 버퍼들(50) 중 인덱스 q를 갖는 버퍼에 저장하는 단계(p=0, ..., n-1; q=0, ... n-2; k는 정수); 및 상기 컴퓨팅 장치가, 상기 제1세트의 버퍼들 중 인덱스 0 내지 n-1의 값들에 대하여 풀링한 결과값을 풀링버퍼(60) 중 인덱스 j을 갖는 버퍼에 저장하는 단계;를 포함한다.
이때, 상기 방법은, 상기 내부메모리에 저장하는 단계 이전에, 상기 컴퓨팅 장치가, 상기 입력 어레이 중 인덱스 k 내지 인덱스 k+2n-1 의 엘리먼트들을 읽어 내부메모리(30)에 저장하는 단계를 더 포함할 수 있다.
이때, 상기 방법은, 상기 인덱스 q를 갖는 버퍼에 저장하는 단계와 상기 인덱스 j를 갖는 버퍼에 저장하는 단계 사이에, 상기 컴퓨팅 장치가, 상기 입력 어레이 중 인덱스 k 내지 인덱스 k+2n-2의 값을 삭제하는 단계를 더 포함할 수 있다.
이때, 상기 방법은, 상기 컴퓨팅 장치가, 인덱스 k+2n-1 및 인덱스 k+2n 의 엘리먼트로 이루어지는 쌍에 대하여 풀링한 결과값을 상기 제2세트의 버퍼들 중 인덱스 n-1을 갖는 버퍼에 저장하는 단계; 및 상기 컴퓨팅 장치가, 상기 제2세트의 버퍼들 중 인덱스 0 내지 n-1의 값들에 대하여 풀링하여 상기 풀링버퍼 중 인덱스 j+1을 갖는 버퍼에 저장하는 단계;를 더 포함할 수 있다.
이때, 상기 방법은, 상기 인덱스 j를 갖는 버퍼에 저장하는 단계와 상기 인덱스 n-1을 갖는 버퍼에 저장하는 단계 사이에, 상기 컴퓨팅 장치가, 상기 입력 어레이 중 인덱스 k+2n의 엘리먼트를 읽어 상기 내부메모리에 저장하는 단계를 더 포함할 수 있다.
이때, 상기 방법은, 상기 인덱스 n-1을 갖는 버퍼에 저장하는 단계와 상기 인덱스 j+1을 갖는 버퍼에 저장하는 단계 사이에, 상기 컴퓨팅 장치가, 상기 입력 어레이 중 인덱스 k+2n-1의 값을 삭제하는 단계를 더 포함할 수 있다.
이때, 상기 방법은, 상기 제1세트의 버퍼들 중 인덱스 0을 갖는 버퍼의 값을, 상기 입력 어레이 중 인덱스 k+2n 및 인덱스 k+2n+1의 엘리먼트로 이루어지는 쌍에 대하여 풀링한 결과값으로 갱신하는 단계; 및 상기 제1세트의 버퍼들 중 인덱스 0 내지 n-1의 값들에 대하여 풀링하여 상기 풀링버퍼 중 인덱스 j+2을 갖는 버퍼에 저장하는 단계;를 더 포함할 수 있다.
이때, 상기 방법은, 상기 인덱스 j+1을 갖는 버퍼에 저장하는 단계와 상기 갱신하는 단계 사이에, 상기 입력 어레이 중 인덱스 k+2n+1의 엘리먼트를 읽어 상기 내부메모리에 저장하는 단계를 더 포함할 수 있다.
이때, 상기 방법은, 상기 갱신하는 단계와 상기 인덱스 j+2을 갖는 버퍼에 저장하는 단계 사이에, 상기 입력 어레이 중 인덱스 k+2n의 값을 삭제하는 단계를 더 포함할 수 있다.
본 발명에 따르면 1차원 어레이에 대한 풀링 연산을 위한 연산량을 감소시키는 풀링 방법을 제공할 수 있다.
도 1은 일 실시예에 따른 CNN의 연산구조를 나타낸 것이다.
도 2는 본 발명의 일 실시예에 따라 제공되는 연산 방법이 적용될 수 있는 하드웨어의 구성예를 나타낸 것이다.
도 3은 본 발명의 일 실시예에 따라 제공되는 풀링 방법을 설명하기 위하여 예시한 입력 어레이를 나타낸 것이다.
도 4a 내지 도 4d는 본 발명의 일 실시에에 따라 입력 어레이를 풀링 윈도우에 의해 풀링하는 방법을 나타낸 것이다.
도 5a 내지 도 5d는 본 발명의 다른 실시에에 따라 입력 어레이를 풀링 윈도우에 의해 풀링하는 방법을 나타낸 것이다.
도 6a 내지 도 6d는 본 발명의 또 다른 실시예에 따라 입력 어레이를 풀링 윈도우에 의해 풀링하는 방법을 나타낸 것이다.
도 7a 내지 도 7d는 본 발명의 또 다른 실시예에 따라 입력 어레이를 풀링 윈도우에 의해 풀링하는 방법을 나타낸 것이다.
도 8a 내지 도 8c는 본 발명의 일 실시예에 따라 풀링을 하는 방법을 나타낸 순서도이다.
이하, 본 발명의 실시예를 첨부한 도면을 참고하여 설명한다. 그러나 본 발명은 본 명세서에서 설명하는 실시예에 한정되지 않으며 여러 가지 다른 형태로 구현될 수 있다. 본 명세서에서 사용되는 용어는 실시예의 이해를 돕기 위한 것이며, 본 발명의 범위를 한정하고자 의도된 것이 아니다. 또한, 이하에서 사용되는 단수 형태들은 문구들이 이와 명백히 반대의 의미를 나타내지 않는 한 복수 형태들도 포함한다.
도 2는 본 발명의 일 실시예에 따라 제공되는 연산 방법이 적용될 수 있는 하드웨어의 구성예를 나타낸 것이다.
도 2는 본 발명의 일 실시예에 따라 제공되는 연산 방법을 하드웨어로 구현한 컴퓨팅 장치 중 일부의 주요 구조를 나타낸 것이다.
컴퓨팅 장치(1)는, DRAM(Dynamic Random Access Memory)(130), 하드웨어 가속기(110), DRAM(130)와 하드웨어 가속기(110)를 연결하는 버스(700), 및 버스(700)에 연결된 타 하드웨어들(99) 및 메인 프로세서(160)를 포함할 수 있다. 여기서 DRAM(130)은 메모리(130)로 지칭될 수 있다.
그 밖에 컴퓨팅 장치(1)는 도시되지 않은 전원부, 통신부, 사용자 인터페이스, 저장부(170), 및 주변 장치부들을 더 포함할 수 있다. 버스(700)는 상기 하드웨어 가속기(110)와 타 하드웨어들(99), 그리고 메인 프로세서(160)가 공유할 수도 있다.
상기 하드웨어 가속기(110)는 DMA부(Direct Memory Access part)(20), 제어부(114), 내부 메모리(30), 입력버퍼(650), 데이터 연산부(610), 및 출력버퍼(640)를 포함할 수 있다.
내부 메모리(30)에 임시 저장되는 데이터의 일부 또는 전부는 버스(700)를 통해 DRAM(130)으로부터 제공될 수 있다. 이때, DRAM(130)에 저장되어 있는 데이터를 내부 메모리(30)로 이동시키기 위하여, 제어부(114)와 DMA부(112)가 내부 메모리(30) 및 DRAM(130)을 제어할 수도 있다.
내부 메모리(30)에 저장되어 있던 데이터는 입력버퍼(650)를 통해 데이터 연산부(610)에게 제공될 수 있다.
상기 데이터 연산부(610)가 동작하여 생성된 출력값들은 출력버퍼(640)을 거쳐 상기 내부 메모리(30)에 저장될 수 있다. 상기 내부 메모리(30)에 저장된 상기 출력값들은 제어부(114) 및 DMA부(112)의 제어에 의해 DRAM(130)에 기록될 수도 있다.
제어부(114)는 DMA부(112), 내부 메모리(30), 및 상기 데이터 연산부(610)의 동작을 총괄하여 제어할 수 있다.
일 구현예에서, 상기 데이터 연산부(610)는 제1시구간 동안에는 제1연산기능을 수행하고 제2시구간 동안에는 제2연산기능을 수행할 수 있다.
도 2에서, 상기 데이터 연산부(610)는 상기 하드웨어 가속기(110) 내에 1개가 제시되어 있다. 그러나 도시하지 않은 변형된 일 실시예에서, 도 2에 나타낸 상기 데이터 연산부(610)는 상기 하드웨어 가속기(110) 내에 복수 개 제공되어 각각 제어부(114)에 의해 요청된 연산을 병렬적으로 수행할 수도 있다.
일 구현예에서, 상기 데이터 연산부(610)는 그 출력데이터를 한 번에 출력하지 않고 시간에 따라 주어진 순서에 따라 순차적으로 출력할 수 있다.
도 3은 본 발명의 일 실시예에 따라 제공되는 풀링 방법을 설명하기 위하여 예시한 입력 어레이를 나타낸 것이다.
입력 어레이(10)는 상기 DRAM(130)에 저장되어 있는 것일 수 있다. 도 3에서는 상기 입력 어레이(10)가 총 13개의 요소로 구성된 것으로 도시하였으나, 이는 설명의 편의를 위한 것이며 상기 입력 어레이(10)에 포함된 요소들의 개수는 이와 다른 값을 가질 수 있다.
상기 제어부(114) 또는 상기 DMA부(112)는 상기 입력 어레이(10)의 전부 또는 일부를 상기 DRAM(130)로부터 읽어 상기 내부 메모리(30)에 저장할 수 있다.
상기 제어부(114)는 상기 내부 메모리(30)에 저장되어 있는 상기 입력 어레이(10)의 전부 또는 일부를 상기 입력버퍼(650)에 저장할 수 있다.
이하 설명하는 풀링방법은 상기 입력 어레이(10)를 미리 결정된 크기를 갖는 풀링 윈도우(20)를 이용하여 풀링하는 방법에 관한 것이다. 이때, 상기 풀링 윈도우(20)에 의해 선택되는 상기 입력 어레이(10)의 요소들의 개수는 짝수(=2n)일 수 있다. 도 3에 나타낸 예에서 상기 풀링 윈도우(20)에 8개의 요소들이 포함된다. 도 3의 예에서 n=4이다.
도 3에서 예시한 풀링은 예컨대 MAX 풀링일 수 있다. 이 경우 상기 풀링 윈도우(20)에 의해 선택되는 8개의 요소들의 값 중 가장 큰 값이 풀링의 결과로서 출력될 수 있다. 그러나 본 발명의 풀링이 상기 MAX 풀링으로 제한되는 것은 아니며, 가능한 다양한 풀링 방법이 적용될 수 있다.
도 3에 나타낸 인덱스 k는 설명의 편의를 위해 도입한 것으로서, 임의의 정수일 수 있다. 상기 인덱스 k는 상기 입력 어레이(10)의 첫 번째 요소를 나타낸다.
이하, 도 4a 내지 도 4d를 통칭하여 도 4라고 지칭한다.
도 4는 본 발명의 일 실시예에 따라 입력 어레이를 풀링 윈도우에 의해 풀링하는 방법을 나타낸 것이다.
도 4a는 상기 입력 어레이 중 풀링 윈도우에 의해 선택된 일부가 저장되어 있는 상기 내부 메모리의 상태를 나타낸 것이다.
이하, 풀링 윈도우의 크기, 즉, 풀링 윈도우에 의해 선택되는 요소들의 개수는 2n인 것으로 가정한다(n은 자연수). 도 4a에서 n은 4이다.
이하 본 명세서에서 '풀링 윈도우(20[+s])'의 s는 풀링 윈도우(20)가 최초의 위치에서 스트라이드 s만큼 이동한 상태의 풀링 윈도우를 의미한다(s는 정수). 예컨대, 풀링 윈도우(20[+0])은 입력 어레이(10) 중 인덱스 k+0 내지 인덱스 k+2n-1 의 값들을 선택한다. 마찬가지로 풀링 윈도우(20[+s])은 입력 어레이(10) 중 인덱스 k+s 내지 인덱스 k+2n-1+s 의 값들을 선택한다.
도 4a에서 상기 풀링 윈도우(20[+0])에 의해 선택된 2n개의 요소들은 상기 내부 메모리(30)의 인덱스 k 내지 인덱스 k+2n-1 로 표현된다.
일 실시예에서, 상기 풀링 윈도우(20[+0])에 의해 선택된 2n개의 요소들을 저장하기 위한 2n 크기의 공간이 상기 내부 메모리(30) 내에 할당될 수 있다. 이러한 할당 작업은 상기 제어부(114)에 의해 이루어질 수도 있다.
도 4b는 본 발명의 일 실시예에 따라 상기 풀링 윈도우에 의해 선택된 요소들을 두 개의 서로 다른 세트의 버퍼들에 저장하는 과정을 나타낸 것이다.
상기 서로 다른 세트의 버퍼들은 제1세트의 버퍼들(40) 및 제2세트의 버퍼들(50)일 수 있다. 일 실시예에서, 상기 제1세트의 버퍼들(40) 및 상기 제2세트의 버퍼들(50)은 상기 입력버퍼(650)의 일부일 수 있다.
단계(S100)에서, 상기 제어부(114)는 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들을 내부 메모리(30)로 이동시킬 수 있다.
일 실시예에서, 상기 제어부(114)는 상기 입력 어레이(10)가 저장되어 있는 DRAM(130) 내의 주소를 획득할 수 있다. 그 후, 상기 제어부는 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들을 상기 DRAM(130)으로부터 읽어서 상기 내부 메모리(30)에 준비된 공간으로 이동할 수 있다. 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들은 예컨대, 상기 입력 어레이(10) 중 가장 작은 인덱스를 포함하는 연속적인 2n개의 요소들일 수 있다.
단계(S110)에서, 상기 제어부(114)는, 인덱스 k+2p 및 인덱스 k+2p+1 의 엘리먼트로 이루어지는 쌍에 대하여 풀링하여, 상기 풀링한 결과값을 제1세트의 버퍼들(40) 중 인덱스 p를 갖는 버퍼에 저장할 수 있다(p=0, ... , n-1, 여기서 2n은 풀링 윈도우의 크기). 예컨대, 제1세트의 버퍼들(40) 중 인덱스 0를 갖는 버퍼에는 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들 중 인덱스 k 및 인덱스 k+1 의 엘리먼트로 이루어지는 쌍에 대한 풀링한 결과값인 '8'이 저장될 수 있다. 마찬가지로, 제1세트의 버퍼들(40) 중 인덱스 2를 갖는 버퍼에는 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들 중 인덱스 k+4 및 인덱스 k+5 의 엘리먼트로 이루어지는 쌍에 대한 풀링한 결과값인 '2'이 저장될 수 있다. 도 4b의 예에서, 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들에 의하여 상기 제1세트의 버퍼들(40)의 인덱스 0 내지 인덱스 3(즉, 인덱스 n-1)의 값이 결정될 수 있다.
단계(S120)에서, 상기 제어부(114)는, 인덱스 k+2q+1 및 인덱스 k+2q+2 의 엘리먼트로 이루어지는 쌍에 대하여 풀링하여, 상기 풀링한 결과값을 제2세트의 버퍼들(50) 중 인덱스 q를 갖는 버퍼에 저장할 수 있다(q=0, ... , n-2, 여기서 2n은 풀링 윈도우의 크기). 예컨대, 제2세트의 버퍼들(50) 중 인덱스 0를 갖는 버퍼에는 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들 중 인덱스 k+1 및 인덱스 k+2 의 엘리먼트로 이루어지는 쌍에 대한 풀링한 결과값인 '8'이 저장될 수 있다. 마찬가지로, 제2세트의 버퍼들(50) 중 인덱스 2를 갖는 버퍼에는 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들 중 인덱스 k+5 및 인덱스 k+6의 엘리먼트로 이루어지는 쌍에 대한 풀링한 결과값인 '3'이 저장될 수 있다. 도 4b의 예에서, 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들에 의하여 상기 제2세트의 버퍼들(50)의 인덱스 0 내지 인덱스 2(즉, 인덱스 n-2)의 값이 결정될 수 있다.
단계(S120)에서, 상기 인덱스 k+2q+1 및 인덱스 k+2q+2 의 엘리먼트로 이루어지는 쌍에 대한 풀링인 최소 풀링은 데이터 연산부(610)가 실행할 수 있다. 이때, 상기 제어부(114)는 상기 데이터 연산부(610)가 상기 최소 풀링을 실행하도록 상기 데이터 연산부(610)의 기능을 제어할 수 있다.
상기 단계(S110)와 단계(S120) 간의 실행순서는 변경될 수 있다.
도 4c는, 본 발명의 일 실시예에 따라 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들 중 풀링에 사용된 요소들의 일부를 삭제하는 과정을 나타낸 것이다.
단계(S130)에서, 상기 제어부(114)는, 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들 중 인덱스 k 내지 인덱스 k+2n-2의 값을 삭제할 수 있다(도 4c에서 문자 'X'로 표시). 즉, 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들 중 마지막 인덱스 k+2n-1의 값을 제외한 값들을 삭제할 수 있다.
변형된 실시예에서는 단계(S130)를 반드시 실행하지 않을 수도 있다. 그러나 단계(S130)를 실행하면 상기 내부 메모리(30)의 공간 중 일부를 다른 작업을 위해 할당할 수 있다.
도 4d는, 본 발명의 일 실시예에 따라 풀링된 결과를 풀링버퍼에 저장하는 과정을 나타낸 것이다.
단계(S140)에서, 상기 제어부(114)는, 상기 제1세트의 버퍼들(40) 중 인덱스 0 내지 n-1의 값들에 대하여 풀링을 실행하고, 풀링한 결과값을 풀링버퍼(60) 중 인덱스 j을 갖는 버퍼에 저장할 수 있다. 예컨대, 도 4d에 나타낸 것과 같이, 상기 제1세트의 버퍼들(40) 중 인덱스 0 내지 3의 값들에 대하여 풀링을 실행하고, 상기 풀링한 결과값인 '8'을 풀링버퍼(60) 중 인덱스 j을 갖는 버퍼에 저장할 수 있다.
상기 풀링버퍼(60)는 상기 제1세트의 버퍼들(40) 및 상기 제2세트의 버퍼들(50)과는 다른 버퍼일 수 있으며, 상기 내부 메모리(30)에 포함된 것이거나 또는 상기 입력버퍼(650)에 포함된 것일 수 있다. 도 4d에 나타낸 문자 j는 설명의 편의를 위해 도입한 것으로서, 임의의 정수일 수 있다.
단계(S140)에 의해 상기 풀링 윈도우(20[+0])에 의해 선택된 값들에 대한 풀링 프로세스라 완결되었다. 이제 상기 풀링 윈도우(20[+0])를 소정의 스트라이드만큼 이동하여 상기 입력 어레이(10)로부터 데이터를 새롭게 선택하고, 새로 선택된 데이터에 대한 풀링을 실행할 수 있다. 바람직한 실시예에서, 상기 소정의 스트라이드는 '1'의 값을 가질 수 있다.
도 4b에 제시된 풀링 윈도우(20[+0])로부터 인덱스 k가 증가하는 방향으로 스트라이드 1만큼 이동한 풀링 윈도우를 풀링 윈도우(20[+1])로 표현할 수 있다.
본 발명에서는 위치가 이동된 상기 풀링 윈도우(20[+1])에 의해 입력 어레이(10)로부터 새로 선택된 2n개의 데이터 중 일부만을 이용하여 풀링을 실행할 수 있다. 이하 그 방법에 대하여 설명한다.
스트라이드 1만큼 이동한 상기 풀링 윈도우(20[+1])에 의해 선택되는 데이터는 상기 입력 어레이(10)의 인덱스 k+1 내지 인덱스 k+8이다. 즉, 상기 풀링 윈도우(20[+1])에 의해 상기 입력 어레이(10)의 인덱스 k+1 내지 인덱스 k+2n이 선택될 수 있다.
그러나 본 발명의 일 실시예에서, 상기 입력 어레이(10)의 인덱스 k+1 내지 인덱스 k+6의 각각의 값을 다시 이용되지 않을 수 있다. 즉, 상기 입력 어레이(10)의 인덱스 k+1 내지 인덱스 k+2n-2의 각각의 값은 다시 이용되지 않을 수 있다. 그 대신, 상기 제1세트의 버퍼들(40) 및 상기 제2세트의 버퍼들(50)에 이미 저장되어 있는 데이터를 대신 이용할 수 있으며, 이에 대해서는 뒤에서 따로 설명한다.
본 발명의 일 실시예에서, 상기 입력 어레이(10)의 인덱스 k+8의 값만을 상기 DRAM(130)로부터 읽어서 상기 내부 메모리(30)에 기록할 수 있다. 즉, 상기 입력 어레이(10)의 인덱스 k+2n만을 읽어서 상기 내부 메모리(30)에 기록할 수 있다. 이때, 상기 입력 어레이(10)의 인덱스 k+8의 값은 상기 DRAM(130)가 아닌 다른 곳에서 제공될 수도 있다.
이하, 도 5a 내지 도 5d를 통칭하여 도 5라고 지칭한다.
도 5는 본 발명의 다른 실시예에 따라 입력 어레이를 풀링 윈도우에 의해 풀링하는 방법을 나타낸 것이다.
도 5a는, 본 발명의 일 실시예에 따라 내부 메모리에 상기 입력 어레이(10)의 인덱스 k+8의 값이 저장된 상태를 나타낸다.
단계(S149)에서, 제어부(114)는 DRAM(130)으로부터 입력 어레이 중 인덱스 k+2n (=k+8)의 값을 읽어서 내부 메모리(30)에 저장할 수 있다.
도 5a에 제시된 'X'는 상기 입력 어레이(10)의 인덱스 k+0 내지 인덱스 k+6의 각각의 값은 풀링 연산을 위해 더 이상 필요 없음을 나타낸다.
도 5b는 상기 제2세트의 버퍼들 중 인덱스 n-1을 갖는 버퍼의 값을 결정하는 과정을 나타낸 것이다.
상기 단계(S120)에서, 상기 제2세트의 버퍼들(50) 중 인덱스 n-1 (=3)의 값은 결정되지 않았다. 그러나 이제 상기 입력 어레이(10)의 인덱스 k+2n (=k+8)의 값이 준비되어 있기 때문에, 인덱스 k+2n-1 및 인덱스 k+2n의 값을 풀링하여 상기 제2세트의 버퍼들(50) 중 인덱스 n-1의 값은 결정할 수 있다.
단계(S150)에서, 상기 제어부(114)는, 인덱스 k+2n-1 및 인덱스 k+2n의 엘리먼트로 이루어지는 쌍에 대하여 풀링하여, 상기 풀링한 결과값을 제2세트의 버퍼들(50) 중 인덱스 n-1를 갖는 버퍼에 저장할 수 있다. 즉, 도 5b의 예에서, 인덱스 k+7 및 인덱스 k+8의 엘리먼트로 이루어지는 쌍에 대하여 풀링하여, 상기 풀링한 결과값인 '9'를 제2세트의 버퍼들(50) 중 인덱스 3을 갖는 버퍼에 저장할 수 있다. 이제 상기 제2세트의 버퍼들(50)의 총 n개의 인덱스들의 값이 모두 결정되었다.
도 5c는, 본 발명의 일 실시예에 따라 스트라이드 1만큼 이동한 상기 풀링 윈도우(20[+1])에 의해 선택된 요소들 중 풀링에 사용된 요소들의 일부를 삭제하는 과정을 나타낸 것이다.
단계(S160)에서, 상기 제어부(114)는, 상기 풀링 윈도우(20[+1])에 의해 선택된 요소들 중 인덱스 k+2n-1(=k+7)의 값을 삭제할 수 있다(도 5c에서 문자 'X'로 표시). 즉, 상기 풀링 윈도우(20[+1])에 의해 선택된 요소들 중 마지막 인덱스 k+2n(=k+8)의 값을 제외한 값들을 삭제할 수 있다.
변형된 실시예에서는 단계(S160)를 반드시 실행하지 않을 수도 있다. 그러나 단계(S160)를 실행하면 상기 내부 메모리(30)의 공간 중 일부를 다른 작업을 위해 할당할 수 있다.
도 5d는, 본 발명의 일 실시예에 따라 풀링된 결과를 풀링버퍼에 저장하는 과정을 나타낸 것이다.
단계(S170)에서, 상기 제어부(114)는, 상기 제2세트의 버퍼들(50) 중 인덱스 0 내지 n-1의 값들에 대하여 풀링을 실행하고, 풀링한 결과값을 풀링버퍼(60) 중 인덱스 j+1을 갖는 버퍼에 저장할 수 있다. 예컨대, 도 5d에 나타낸 것과 같이, 상기 제2세트의 버퍼들(50) 중 인덱스 0 내지 3의 값들에 대하여 풀링을 실행하고, 상기 풀링한 결과값인 '9'를 풀링버퍼(60) 중 인덱스 j+1을 갖는 버퍼에 저장할 수 있다.
단계(S170)에 의해 상기 풀링 윈도우(20[+1])에 의해 선택된 값들에 대한 풀링 프로세스가 완결되었다. 이제 상기 풀링 윈도우(20[+1])를 스트라이드 1만큼 더 이동하여 상기 입력 어레이(10)로부터 데이터를 새롭게 선택하고, 새로 선택된 데이터에 대한 풀링을 실행할 수 있다. 상기 풀링 윈도우(20[+1])를 스트라이드 1만큼 더 이동한 풀링 윈도우를 이하 풀리 윈도우(20[+2])라고 지칭할 수 있다.
이하, 도 6a 내지 도 6d를 통칭하여 도 6이라고 지칭한다.
도 6은 본 발명의 또 다른 실시예에 따라 입력 어레이를 풀링 윈도우에 의해 풀링하는 방법을 나타낸 것이다.
도 6a는, 본 발명의 일 실시예에 따라 내부 메모리에 상기 입력 어레이(10)의 인덱스 k+9의 값이 저장된 상태를 나타낸다.
단계(S179)에서, 제어부(114)는 DRAM(130)으로부터 입력 어레이 중 인덱스 k+2n+1(=k+9)의 값을 읽어서 내부 메모리(30)에 저장할 수 있다.
도 6a에 제시된 'X'는 상기 입력 어레이(10)의 인덱스 k+0 내지 인덱스 k+7의 각각의 값은 풀링 연산을 위해 더 이상 필요 없음을 나타낸다.
도 6b은 상기 제1세트의 버퍼들 중 인덱스 0을 갖는 버퍼의 값을 갱신하는 과정을 나타낸 것이다.
상기 단계(S110)에서, 상기 제1세트의 버퍼들(40) 중 인덱스 0 내지 인덱스 n-1을 갖는 버퍼들의 값은 모두 결정되었다. 그러나 이제 상기 단계(S110)의 시점과 비교하여, 상기 풀링 윈도우(20[+2])가 총 스트라이트 2만큼 이동하였기 때문에, 상기 입력 어레이(10)의 인덱스 k+0 및 인덱스 k+1의 값은 필요가 없어졌다. 그 결과, 상기 제1세트의 버퍼들(40) 중 인덱스 0의 값도 필요가 없어졌다. 그 대신, 상기 단계(S110)의 시점과 비교하여, 상기 풀링 윈도우(20[+2])가 총 스트라이드 2만큼 이동하였기 때문에, 상기 입력 어레이(10)의 인덱스 k+2n (=k+8) 및 인덱스 k+2n+1 (=k+9)의 값이 더 준비되었다.
그 결과, 단계(S180)에서, 상기 제어부(114)는, 상기 제1세트의 버퍼들(40) 중 인덱스 0을 갖는 버퍼의 값을 상기 입력 어레이(10)의 인덱스 k+2n 및 인덱스 k+2n+1의 값들로 이루어진 쌍을 풀링한 값으로 갱신할 수 있다.
이제, 도 6b의 예에서, 상기 풀링 윈도우(20[+2])에 의해 선택되는 n개의 데이터들을 2개씩 부분 풀링한 결과값들 모두가 상기 제1세트의 버퍼들(40)에 모두 저장되어 있다. 따라서 상기 제1세트의 버퍼들(40)들을 풀링함으로써 상기 풀링 윈도우(20[+2])에 대한 풀링을 완료할 수 있다.
도 6c는, 본 발명의 일 실시예에 따라 상기 풀링 윈도우(20[+2])에 의해 선택된 요소들 중 풀링에 사용된 요소들의 일부를 삭제하는 과정을 나타낸 것이다.
단계(S190)에서, 상기 제어부(114)는, 상기 풀링 윈도우(20[+2])에 의해 선택된 요소들 중 인덱스 k+2n(=k+8)의 값을 삭제할 수 있다(도 6c에서 문자 'X'로 표시). 즉, 상기 풀링 윈도우(20[+2])에 의해 선택된 요소들 중 마지막 인덱스 k+2n+1(=k+9)의 값을 제외한 값들을 삭제할 수 있다.
변형된 실시예에서는 단계(S190)를 반드시 실행하지 않을 수도 있다. 그러나 단계(S190)를 실행하면 상기 내부 메모리(30)의 공간 중 일부를 다른 작업을 위해 할당할 수 있다.
도 6d는, 본 발명의 일 실시예에 따라 풀링된 결과를 풀링버퍼에 저장하는 과정을 나타낸 것이다.
단계(S200)에서, 상기 제어부(114)는, 상기 제1세트의 버퍼들(40) 중 인덱스 0 내지 n-1의 값들에 대하여 풀링을 실행하고, 풀링한 결과값을 풀링버퍼(60) 중 인덱스 j+2을 갖는 버퍼에 저장할 수 있다. 예컨대, 도 6d에 나타낸 것과 같이, 상기 제1세트의 버퍼들(40) 중 인덱스 0 내지 3의 값들에 대하여 풀링을 실행하고, 상기 풀링한 결과값인 '10'을 풀링버퍼(60) 중 인덱스 j+2을 갖는 버퍼에 저장할 수 있다.
단계(S200)에 의해 상기 풀링 윈도우(20[+2])에 의해 선택된 값들에 대한 풀링 프로세스라 완결되었다. 이제 상기 풀링 윈도우(20[+2])를 스트라이드 1만큼 더 이동하여 상기 입력 어레이(10)로부터 데이터를 새롭게 선택하고, 새로 선택된 데이터에 대한 풀링을 실행할 수 있다.
이하, 도 7a 내지 도 7d를 통칭하여 도 7이라고 지칭한다.
도 7은 본 발명의 일 실시예에 따라 입력 어레이를 풀링 윈도우에 의해 풀링하는 방법을 나타낸 것이다.
도 7a는, 본 발명의 일 실시예에 따라 내부 메모리에 상기 입력 어레이(10)의 인덱스 k+11의 값이 저장된 상태를 나타낸다.
도 7a에 제시된 'X'는 상기 입력 어레이(10)의 인덱스 k+0 내지 인덱스 k+8의 각각의 값은 풀링 연산을 위해 더 이상 필요 없음을 나타낸다.
도 7b는 상기 제2세트의 버퍼들 중 인덱스 0을 갖는 버퍼의 값을 결정하는 과정을 나타낸 것이다.
상기 제어부(114)는, 인덱스 k+2n+1(=k+9) 및 인덱스 k+2n+2(=k+10)의 엘리먼트로 이루어지는 쌍에 대하여 풀링하여, 상기 풀링한 결과값을 제2세트의 버퍼들(50) 중 인덱스 0을 갖는 버퍼에 저장할 수 있다. 즉, 도 7b의 예에서, 인덱스 k+9 및 인덱스 k+10의 엘리먼트로 이루어지는 쌍에 대하여 풀링하여, 상기 풀링한 결과값인 '11'을 제2세트의 버퍼들(50) 중 인덱스 0을 갖는 버퍼에 저장할 수 있다. 이제 상기 제2세트의 버퍼들(50)의 총 n개의 인덱스들의 값이 모두 결정되었다.
도 7c는, 본 발명의 일 실시예에 따라 상기 풀링 윈도우(20[+3])에 의해 선택된 요소들 중 풀링에 사용된 요소들의 일부를 삭제하는 과정을 나타낸 것이다.
상기 제어부(114)는, 상기 풀링 윈도우(20[+3])에 의해 선택된 요소들 중 인덱스 k+2n+1(=k+9)의 값을 삭제할 수 있다(도 7c에서 문자 'X'로 표시). 즉, 상기 풀링 윈도우(20[+3])에 의해 선택된 요소들 중 마지막 인덱스 k+2n+2(=k+10)의 값을 제외한 값들을 삭제할 수 있다.
도 7d는, 본 발명의 일 실시예에 따라 풀링된 결과를 풀링버퍼에 저장하는 과정을 나타낸 것이다.
상기 제어부(114)는, 상기 제2세트의 버퍼들(50) 중 인덱스 0 내지 n-1의 값들에 대하여 풀링을 실행하고, 풀링한 결과값을 풀링버퍼(60) 중 인덱스 j+3을 갖는 버퍼에 저장할 수 있다. 예컨대, 도 7d에 나타낸 것과 같이, 상기 제2세트의 버퍼들(50) 중 인덱스 0 내지 3의 값들에 대하여 풀링을 실행하고, 상기 풀링한 결과값인 '11'를 풀링버퍼(60) 중 인덱스 j+3을 갖는 버퍼에 저장할 수 있다.
이로써 상기 풀링 윈도우(20[+3])에 의해 선택된 값들에 대한 풀링 프로세스가 완결되었다.
도 4 내지 도 7을 이용하여 설명한 본 발명의 실시예들을 다음과 같이 정리할 수 있다.
도 4에 설명한 방법은, 풀링 윈도우(20)를 이용하여 입력 어레이(10)로부터 최초의 풀링을 실행하는 방법을 나타낸 것이다.
도 5에 설명한 방법은, 풀링 윈도우(20)로부터 스트라이드 1만큼 이동한 풀링 윈도우(20[+1])를 이용하여 풀링을 실행하는 방법을 나타낸 것이다.
도 6에 설명한 방법은, 풀링 윈도우(20)로부터 스트라이드 2만큼 이동한 풀링 윈도우(20[+2])를 이용하여 풀링을 실행하는 방법을 나타낸 것이다.
도 7에 설명한 방법은, 풀링 윈도우(20)로부터 스트라이드 3만큼 이동한 풀링 윈도우(20[+3])를 이용하여 풀링을 실행하는 방법을 나타낸 것이다.
도 5와 도 7의 방법을 살펴보면, 풀링 윈도우의 최초의 위치로부터 홀수(1, 3, 5...)의 스트라이드만큼 이동한 풀링 윈도우를 이용한 경우, 그 스트라이드 값만 다를 뿐 그 과정이 동일하다는 것을 이해할 수 있다.
마찬가지로, 풀링 윈도우의 최초의 위치로부터 짝수(2, 4, 6...)의 스트라이드만큼 이동한 풀링 윈도우를 이용한 경우, 그 스트라이드 값만 다를 뿐 그 과정이 동일하다는 것을 이해할 수 있다.
도 4에 나타낸 프로세스를 시작 프로세스(P0)라고 지칭할 수 있다.
도 5에 나타낸 프로세스를 홀수 스트라이드 프로세스(P1)라고 지칭할 수 있다.
도 6에 나타낸 프로세스를 짝수 스트라이드 프로세스(P2)라고 지칭할 수 있다.
본 발명의 일 실시예에 따르면, 상기 시작 프로세스(P0)를 실행한 이후, 상기 홀수 스트라이드 프로세스(P1)와 상기 짝수 스트라이드 프로세스(P2)를 번갈아 실행함으로써(P0→P1→P2→P1→P2→P1→P2→....), 입력 어레이(10)에 대한 풀링 윈도우(20)를 이용한 풀링을 완료할 수 있다. 그 결과 풀링버퍼(60)에 완성된 풀링값을 저장하고, 이를 필요한 다른 프로세스에 이용할 수 있다.
이하, 도 8a, 도 8b, 및 도 8c를 도 8이라고 통칭한다.
도 8a는 본 발명의 일 실시예에 따라 제공되는 풀링 방법을 나타낸 순서도이다.
도 8b는 본 발명의 다른 실시예에 따라 제공되는 풀링 방법을 나타낸 순서도이다.
도 8c는 본 발명의 또 다른 실시예에 따라 제공되는 풀링 방법을 나타낸 순서도이다.
도 8a, 도 8b, 및 도 8c에 나타낸 방법들을 각각, 시작 풀링 프로세스(P0), 홀수 스트라이드 풀링 프로세스(P1), 및 짝수 스트라이드 풀링 프로세스(P2)라고 지칭할 수 있다.
도 8a에 제시한 방법은 다음 단계들을 포함할 수 있다.
단계(S100)에서, 상기 제어부(114)는 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들을 내부 메모리(30)로 이동시킬 수 있다.
단계(S110)에서, 상기 제어부(114)는, 인덱스 k+2p 및 인덱스 k+2p+1 의 엘리먼트로 이루어지는 쌍에 대하여 풀링하여, 상기 풀링한 결과값을 제1세트의 버퍼들(40) 중 인덱스 p를 갖는 버퍼에 저장할 수 있다(p=0, ... , n-1, 여기서 2n은 풀링 윈도우의 크기).
단계(S120)에서, 상기 제어부(114)는, 인덱스 k+2q+1 및 인덱스 k+2q+2 의 엘리먼트로 이루어지는 쌍에 대하여 풀링하여, 상기 풀링한 결과값을 제2세트의 버퍼들(50) 중 인덱스 q를 갖는 버퍼에 저장할 수 있다(q=0, ... , n-2, 여기서 2n은 풀링 윈도우의 크기).
단계(S130)에서, 상기 제어부(114)는, 상기 풀링 윈도우(20[+0])에 의해 선택된 요소들 중 인덱스 k 내지 인덱스 k+2n-2의 값을 삭제할 수 있다(도 4c에서 문자 'X'로 표시).
단계(S140)에서, 상기 제어부(114)는, 상기 제1세트의 버퍼들(40) 중 인덱스 0 내지 n-1의 값들에 대하여 풀링을 실행하고, 풀링한 결과값을 풀링버퍼(60) 중 인덱스 j을 갖는 버퍼에 저장할 수 있다.
도 8b에 제시한 방법은 다음 단계들을 포함할 수 있다.
단계(S149)에서, 제어부(114)는 DRAM(130)으로부터 입력 어레이 중 인덱스 k+2n (=k+8)의 값을 읽어서 내부 메모리(30)에 저장할 수 있다.
단계(S150)에서, 상기 제어부(114)는, 인덱스 k+2n-1 및 인덱스 k+2n의 엘리먼트로 이루어지는 쌍에 대하여 풀링하여, 상기 풀링한 결과값을 제2세트의 버퍼들(50) 중 인덱스 n-1를 갖는 버퍼에 저장할 수 있다.
단계(S160)에서, 상기 제어부(114)는, 상기 풀링 윈도우(20[+1])에 의해 선택된 요소들 중 인덱스 k+2n-1(=k+7)의 값을 삭제할 수 있다.
단계(S170)에서, 상기 제어부(114)는, 상기 제2세트의 버퍼들(50) 중 인덱스 0 내지 n-1의 값들에 대하여 풀링을 실행하고, 풀링한 결과값을 풀링버퍼(60) 중 인덱스 j+1을 갖는 버퍼에 저장할 수 있다.
도 8c에 제시한 방법은 다음 단계들을 포함할 수 있다.
단계(S179)에서, 제어부(114)는 DRAM(130)으로부터 입력 어레이 중 인덱스 k+2n+1(=k+9)의 값을 읽어서 내부 메모리(30)에 저장할 수 있다.
단계(S180)에서, 상기 제어부(114)는, 상기 제1세트의 버퍼들(40) 중 인덱스 0을 갖는 버퍼의 값을 상기 입력 어레이(10)의 인덱스 k+2n 및 인덱스 k+2n+1의 값들로 이루어진 쌍을 풀링한 값으로 갱신할 수 있다.
단계(S190)에서, 상기 제어부(114)는, 상기 풀링 윈도우(20[+2])에 의해 선택된 요소들 중 인덱스 k+2n(=k+8)의 값을 삭제할 수 있다.
단계(S200)에서, 상기 제어부(114)는, 상기 제1세트의 버퍼들(40) 중 인덱스 0 내지 n-1의 값들에 대하여 풀링을 실행하고, 풀링한 결과값을 풀링버퍼(60) 중 인덱스 j+2을 갖는 버퍼에 저장할 수 있다.
상술한 본 발명의 실시예들을 이용하여, 본 발명의 기술 분야에 속하는 자들은 본 발명의 본질적인 특성에서 벗어나지 않는 범위 내에 다양한 변경 및 수정을 용이하게 실시할 수 있을 것이다. 특허청구범위의 각 청구항의 내용은 본 명세서를 통해 이해할 수 있는 범위 내에서 인용관계가 없는 다른 청구항에 결합될 수 있다.
<사사-Acknowledgement>
본 발명은, 오픈엣지테크놀로지 주식회사(과제수행기관)가, 과학기술정보통신부와 한국연구재단 부설 정보통신기획평가원의 지원으로 이루어진 연구사업인 SW컴퓨팅산업원천기술개발 중 엣지 응용 스케일러블 온디바이스 AI컴퓨팅을 위한 모델 경량화 프레임워크 개발(과제고유번호 2021000105, 과제번호 2021-0-00105, 연구기간 2021.04.01 ~ 2024.12.31) 연구과제를 수행하는 과정에서 개발된 것이다.

Claims (9)

  1. 짝수 개의 요소들을 풀링하는 풀링 윈도우(20)로 입력 어레이(10)를 풀링하는 방법으로서,
    컴퓨팅 장치가, 인덱스 k+2p 및 인덱스 k+2p+1 의 엘리먼트로 이루어지는 쌍에 대하여 풀링한 결과값을 제1세트의 버퍼들(40) 중 인덱스 p를 갖는 버퍼에 저장하고, 그리고 인덱스 k+2q+1 및 인덱스 k+2q+2 의 엘리먼트로 이루어지는 쌍에 대하여 풀링한 결과값을 제2세트의 버퍼들(50) 중 인덱스 q를 갖는 버퍼에 저장하는 제1단계(p=0, ..., n-1; q=0, ... n-2; k는 정수); 및
    상기 컴퓨팅 장치가, 상기 제1세트의 버퍼들 중 인덱스 0 내지 n-1의 값들에 대하여 풀링한 결과값을 풀링버퍼(60) 중 인덱스 j을 갖는 버퍼에 저장하는 단계;
    를 포함하는,
    풀링 방법.
  2. 제1항에 있어서,
    상기 제1단계 이전에,
    상기 컴퓨팅 장치가, 상기 입력 어레이 중 인덱스 k 내지 인덱스 k+2n-1 의 엘리먼트들을 읽어 내부메모리(30)에 저장하는 단계를 더 포함하는,
    풀링 방법.
  3. 제1항에 있어서,
    상기 제1단계와 상기 인덱스 j를 갖는 버퍼에 저장하는 단계 사이에,
    상기 컴퓨팅 장치가, 상기 입력 어레이 중 인덱스 k 내지 인덱스 k+2n-2의 값을 삭제하는 단계를 더 포함하는,
    풀링 방법.
  4. 제2항에 있어서,
    상기 컴퓨팅 장치가, 인덱스 k+2n-1 및 인덱스 k+2n 의 엘리먼트로 이루어지는 쌍에 대하여 풀링한 결과값을 상기 제2세트의 버퍼들 중 인덱스 n-1을 갖는 버퍼에 저장하는 단계; 및
    상기 컴퓨팅 장치가, 상기 제2세트의 버퍼들 중 인덱스 0 내지 n-1의 값들에 대하여 풀링하여 상기 풀링버퍼 중 인덱스 j+1을 갖는 버퍼에 저장하는 단계;
    를 더 포함하는,
    풀링 방법.
  5. 제4항에 있어서,
    상기 인덱스 j를 갖는 버퍼에 저장하는 단계와 상기 인덱스 n-1을 갖는 버퍼에 저장하는 단계 사이에,
    상기 컴퓨팅 장치가, 상기 입력 어레이 중 인덱스 k+2n의 엘리먼트를 읽어 상기 내부메모리에 저장하는 단계를 더 포함하는,
    풀링 방법.
  6. 제4항에 있어서,
    상기 인덱스 n-1을 갖는 버퍼에 저장하는 단계와 상기 인덱스 j+1을 갖는 버퍼에 저장하는 단계 사이에,
    상기 컴퓨팅 장치가, 상기 입력 어레이 중 인덱스 k+2n-1의 값을 삭제하는 단계를 더 포함하는,
    풀링 방법.
  7. 제4항에 있어서,
    상기 제1세트의 버퍼들 중 인덱스 0을 갖는 버퍼의 값을, 상기 입력 어레이 중 인덱스 k+2n 및 인덱스 k+2n+1의 엘리먼트로 이루어지는 쌍에 대하여 풀링한 결과값으로 갱신하는 단계;
    상기 제1세트의 버퍼들 중 인덱스 0 내지 n-1의 값들에 대하여 풀링하여 상기 풀링버퍼 중 인덱스 j+2을 갖는 버퍼에 저장하는 단계;
    를 더 포함하는,
    풀링 방법.
  8. 제7항에 있어서,
    상기 인덱스 j+1을 갖는 버퍼에 저장하는 단계와 상기 갱신하는 단계 사이에,
    상기 입력 어레이 중 인덱스 k+2n+1의 엘리먼트를 읽어 상기 내부메모리에 저장하는 단계를 더 포함하는,
    풀링 방법.
  9. 제7항에 있어서,
    상기 갱신하는 단계와 상기 인덱스 j+2을 갖는 버퍼에 저장하는 단계 사이에,
    상기 입력 어레이 중 인덱스 k+2n의 값을 삭제하는 단계를 더 포함하는,
    풀링 방법.
PCT/KR2022/007383 2021-12-24 2022-05-24 어레이 풀링 방법 및 이를 위한 장치 WO2023120829A1 (ko)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
KR10-2021-0187396 2021-12-24
KR1020210187396A KR102403277B1 (ko) 2021-12-24 2021-12-24 어레이 풀링 방법 및 이를 위한 장치

Publications (1)

Publication Number Publication Date
WO2023120829A1 true WO2023120829A1 (ko) 2023-06-29

Family

ID=81800187

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/KR2022/007383 WO2023120829A1 (ko) 2021-12-24 2022-05-24 어레이 풀링 방법 및 이를 위한 장치

Country Status (2)

Country Link
KR (1) KR102403277B1 (ko)
WO (1) WO2023120829A1 (ko)

Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR20070012630A (ko) * 2003-12-30 2007-01-26 쌘디스크 코포레이션 데이터 런 프로그래밍
US20190266784A1 (en) * 2018-02-27 2019-08-29 Stmicroelectronics S.R.L. Data volume sculptor for deep learning acceleration
KR20200100812A (ko) * 2018-01-04 2020-08-26 테슬라, 인크. 하드웨어 기반 풀링을 위한 시스템 및 방법
US20210073569A1 (en) * 2018-05-30 2021-03-11 SZ DJI Technology Co., Ltd. Pooling device and pooling method
KR20210036715A (ko) * 2019-09-26 2021-04-05 삼성전자주식회사 뉴럴 프로세싱 장치 및 뉴럴 프로세싱 장치에서 뉴럴 네트워크의 풀링을 처리하는 방법

Patent Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR20070012630A (ko) * 2003-12-30 2007-01-26 쌘디스크 코포레이션 데이터 런 프로그래밍
KR20200100812A (ko) * 2018-01-04 2020-08-26 테슬라, 인크. 하드웨어 기반 풀링을 위한 시스템 및 방법
US20190266784A1 (en) * 2018-02-27 2019-08-29 Stmicroelectronics S.R.L. Data volume sculptor for deep learning acceleration
US20210073569A1 (en) * 2018-05-30 2021-03-11 SZ DJI Technology Co., Ltd. Pooling device and pooling method
KR20210036715A (ko) * 2019-09-26 2021-04-05 삼성전자주식회사 뉴럴 프로세싱 장치 및 뉴럴 프로세싱 장치에서 뉴럴 네트워크의 풀링을 처리하는 방법

Also Published As

Publication number Publication date
KR102403277B1 (ko) 2022-05-30

Similar Documents

Publication Publication Date Title
WO2018113239A1 (zh) 一种卷积神经网络的数据调度方法、系统及计算机设备
WO2019098538A1 (en) Device and method for processing convolution operation using kernel
WO2020231226A1 (en) Method of performing, by electronic device, convolution operation at certain layer in neural network, and electronic device therefor
WO2022146050A1 (ko) 우울증 진단을 위한 인공지능 연합학습 방법 및 시스템
WO2020204364A2 (ko) 단어의 문맥 정보와 형태론적 정보를 고려한 단어 임베딩 방법 및 장치
EP3963516A1 (en) Teaching gan (generative adversarial networks) to generate per-pixel annotation
WO2019216513A1 (ko) 행 단위 연산 뉴럴 프로세서 및 이를 이용한 데이터 처리 방법
WO2022196945A1 (ko) 개체군 분산 모사 모델 기반 개체군 분산 예측 장치 및 이를 이용한 개체군 분산 예측 방법
WO2022124725A1 (ko) 화합물과 단백질의 상호작용 예측 방법, 장치 및 컴퓨터 프로그램
WO2021137415A1 (ko) 머신 러닝에 기반한 이미지 처리 방법 및 장치
WO2021010671A2 (ko) 뉴럴 네트워크 및 비국소적 블록을 이용하여 세그멘테이션을 수행하는 질병 진단 시스템 및 방법
EP3097492A1 (en) Method and apparatus for preventing bank conflict in memory
WO2023120829A1 (ko) 어레이 풀링 방법 및 이를 위한 장치
WO2016178468A1 (ko) 학습 정보를 제공하기 위한 방법, 시스템 및 비일시성의 컴퓨터 판독 가능한 기록 매체
WO2022255561A1 (ko) 고효율 풀링 방법 및 이를 위한 장치
WO2018101607A1 (ko) 벡터 프로세서 및 그 제어 방법
WO2023177108A1 (en) Method and system for learning to share weights across transformer backbones in vision and language tasks
WO2021246586A1 (ko) 하드웨어 가속기를 위한 파라미터를 메모리로부터 액세스하는 방법 및 이를 이용한 장치
WO2023085535A1 (ko) 1차원 어레이 풀링 방법 및 이를 위한 장치
EP3707646A1 (en) Electronic apparatus and control method thereof
WO2022181919A1 (ko) 가상 현실 기반의 수술 환경을 제공하는 장치 및 방법
WO2022250211A1 (ko) 인티져 타입 데이터의 해상도를 증가시키는 연산방법 및 이를 적용한 장치
WO2021020848A2 (ko) 인공 신경망을 위한 행렬 연산기 및 행렬 연산 방법
WO2022004970A1 (ko) 신경망 기반의 특징점 학습 장치 및 방법
WO2021002523A1 (ko) 뉴로모픽 장치

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 22911469

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE