diff options
| -rw-r--r-- | SpatialBatchNormalization.lua | 39 | ||||
| -rw-r--r-- | SpatialConvolutionLocal.lua | 49 | ||||
| -rw-r--r-- | SpatialCrossMapLRN.lua | 22 | ||||
| -rw-r--r-- | SpatialFractionalMaxPooling.lua | 15 | ||||
| -rw-r--r-- | SpatialFullConvolution.lua | 44 | ||||
| -rw-r--r-- | SpatialMaxUnpooling.lua | 15 | ||||
| -rw-r--r-- | SpatialSubSampling.lua | 31 | ||||
| -rw-r--r-- | SpatialUpSamplingNearest.lua | 13 | ||||
| -rw-r--r-- | THNN.lua | 174 | ||||
| -rw-r--r-- | generic/unfold.c | 136 | ||||
| -rw-r--r-- | generic/unfold.h | 15 | ||||
| -rw-r--r-- | init.c | 38 | ||||
| -rw-r--r-- | lib/THNN/generic/SpatialBatchNormalization.c | 43 | ||||
| -rw-r--r-- | lib/THNN/generic/SpatialConvolutionLocal.c | 153 | ||||
| -rw-r--r-- | lib/THNN/generic/SpatialFractionalMaxPooling.c | 91 | ||||
| -rw-r--r-- | lib/THNN/generic/SpatialFullConvolution.c | 155 | ||||
| -rw-r--r-- | lib/THNN/generic/SpatialMaxUnpooling.c | 57 | ||||
| -rw-r--r-- | lib/THNN/generic/SpatialSubSampling.c | 96 | ||||
| -rw-r--r-- | lib/THNN/generic/SpatialUpSamplingNearest.c | 38 | ||||
| -rw-r--r-- | lib/THNN/generic/THNN.h | 192 | ||||
| -rw-r--r-- | lib/THNN/init.c | 21 |
21 files changed, 790 insertions, 647 deletions
diff --git a/SpatialBatchNormalization.lua b/SpatialBatchNormalization.lua index 2fb92b6..5ea9f1b 100644 --- a/SpatialBatchNormalization.lua +++ b/SpatialBatchNormalization.lua @@ -29,6 +29,7 @@ ]]-- local BN,parent = torch.class('nn.SpatialBatchNormalization', 'nn.Module') +local THNN = require 'nn.THNN' BN.__version = 2 @@ -80,18 +81,18 @@ function BN:updateOutput(input) self.save_std = self.save_std or input.new() self.save_std:resizeAs(self.running_var) - input.nn.SpatialBatchNormalization_updateOutput( - input, - self.output, - self.weight, - self.bias, + input.THNN.SpatialBatchNormalization_updateOutput( + input:cdata(), + self.output:cdata(), + THNN.optionalTensor(self.weight), + THNN.optionalTensor(self.bias), + self.running_mean:cdata(), + self.running_var:cdata(), + self.save_mean:cdata(), + self.save_std:cdata(), self.train, - self.eps, self.momentum, - self.running_mean, - self.running_var, - self.save_mean, - self.save_std) + self.eps) return self.output end @@ -107,15 +108,15 @@ local function backward(self, input, gradOutput, scale, gradInput, gradWeight, g gradInput:resizeAs(gradOutput) end - input.nn.SpatialBatchNormalization_backward( - input, - gradOutput, - gradInput, - gradWeight, - gradBias, - self.weight, - self.save_mean, - self.save_std, + input.THNN.SpatialBatchNormalization_backward( + input:cdata(), + gradOutput:cdata(), + THNN.optionalTensor(gradInput), + THNN.optionalTensor(gradWeight), + THNN.optionalTensor(gradBias), + THNN.optionalTensor(self.weight), + self.save_mean:cdata(), + self.save_std:cdata(), scale) return self.gradInput diff --git a/SpatialConvolutionLocal.lua b/SpatialConvolutionLocal.lua index 75090c5..dd89db6 100644 --- a/SpatialConvolutionLocal.lua +++ b/SpatialConvolutionLocal.lua @@ -119,9 +119,21 @@ function SpatialConvolutionLocal:updateOutput(input) checkInputSize(self, input) viewWeight(self) input = makeContiguous(self, input) - local out = input.nn.SpatialConvolutionLocal_updateOutput(self, input) + input.THNN.SpatialConvolutionLocal_updateOutput( + input:cdata(), + self.output:cdata(), + self.weight:cdata(), + self.bias:cdata(), + self.finput:cdata(), + self.fgradInput:cdata(), + self.kW, self.kH, + self.dW, self.dH, + self.padW, self.padH, + self.iW, self.iH, + self.oW, self.oH + ) unviewWeight(self) - return out + return self.output end function SpatialConvolutionLocal:updateGradInput(input, gradOutput) @@ -130,20 +142,45 @@ function SpatialConvolutionLocal:updateGradInput(input, gradOutput) if self.gradInput then viewWeight(self) input, gradOutput = makeContiguous(self, input, gradOutput) - local out = input.nn.SpatialConvolutionLocal_updateGradInput(self, input, gradOutput) + input.THNN.SpatialConvolutionLocal_updateGradInput( + input:cdata(), + gradOutput:cdata(), + self.gradInput:cdata(), + self.weight:cdata(), + self.finput:cdata(), + self.fgradInput:cdata(), + self.kW, self.kH, + self.dW, self.dH, + self.padW, self.padH, + self.iW, self.iH, + self.oW, self.oH + ) unviewWeight(self) - return out + return self.gradInput end end function SpatialConvolutionLocal:accGradParameters(input, gradOutput, scale) + scale = scale or 1 checkInputSize(self, input) checkOutputSize(self, input, gradOutput) input, gradOutput = makeContiguous(self, input, gradOutput) viewWeight(self) - local out = input.nn.SpatialConvolutionLocal_accGradParameters(self, input, gradOutput, scale) + input.THNN.SpatialConvolutionLocal_accGradParameters( + input:cdata(), + gradOutput:cdata(), + self.gradWeight:cdata(), + self.gradBias:cdata(), + self.finput:cdata(), + self.fgradInput:cdata(), + self.kW, self.kH, + self.dW, self.dH, + self.padW, self.padH, + self.iW, self.iH, + self.oW, self.oH, + scale + ) unviewWeight(self) - return out end function SpatialConvolutionLocal:type(type,tensorCache) diff --git a/SpatialCrossMapLRN.lua b/SpatialCrossMapLRN.lua index 2440cd4..9758c79 100644 --- a/SpatialCrossMapLRN.lua +++ b/SpatialCrossMapLRN.lua @@ -16,7 +16,15 @@ function SpatialCrossMapLRN:updateOutput(input) self.scale = self.scale or input.new() if torch.type(input) == 'torch.CudaTensor' then - input.nn.SpatialCrossMapLRN_updateOutput(self, input) + input.THNN.SpatialCrossMapLRN_updateOutput( + input:cdata(), + self.output:cdata(), + self.scale:cdata(), + self.size, + self.alpha, + self.beta, + self.k + ) else local isBatch = true if input:dim() == 3 then @@ -80,7 +88,17 @@ function SpatialCrossMapLRN:updateGradInput(input, gradOutput) 'Input must be 3D or 4D') if torch.type(input) == 'torch.CudaTensor' then - input.nn.SpatialCrossMapLRN_updateGradInput(self, input, gradOutput) + input.THNN.SpatialCrossMapLRN_updateGradInput( + input:cdata(), + gradOutput:cdata(), + self.gradInput:cdata(), + self.scale:cdata(), + self.output:cdata(), + self.size, + self.alpha, + self.beta, + self.k + ) else local isBatch = true if input:dim() == 3 then diff --git a/SpatialFractionalMaxPooling.lua b/SpatialFractionalMaxPooling.lua index 9dd0f7f..c41b009 100644 --- a/SpatialFractionalMaxPooling.lua +++ b/SpatialFractionalMaxPooling.lua @@ -118,10 +118,11 @@ function SpatialFractionalMaxPooling:updateOutput(input) self:initSampleBuffer_(input) local outW, outH = self:getOutputSizes_(input) - input.nn.SpatialFractionalMaxPooling_updateOutput( - self.output, input, + input.THNN.SpatialFractionalMaxPooling_updateOutput( + input:cdata(), + self.output:cdata(), outW, outH, self.poolSizeW, self.poolSizeH, - self.indices, self.randomSamples) + self.indices:cdata(), self.randomSamples:cdata()) return self.output end @@ -131,10 +132,12 @@ function SpatialFractionalMaxPooling:updateGradInput(input, gradOutput) local outW, outH = self:getOutputSizes_(input) - input.nn.SpatialFractionalMaxPooling_updateGradInput( - self.gradInput, input, gradOutput, + input.THNN.SpatialFractionalMaxPooling_updateGradInput( + input:cdata(), + gradOutput:cdata(), + self.gradInput:cdata(), outW, outH, self.poolSizeW, self.poolSizeH, - self.indices) + self.indices:cdata()) return self.gradInput end diff --git a/SpatialFullConvolution.lua b/SpatialFullConvolution.lua index dc9d944..121a07e 100644 --- a/SpatialFullConvolution.lua +++ b/SpatialFullConvolution.lua @@ -71,7 +71,20 @@ function SpatialFullConvolution:updateOutput(input) self:backCompatibility() input = makeContiguous(self, input) - return input.nn.SpatialFullConvolution_updateOutput(self, input) + input.THNN.SpatialFullConvolution_updateOutput( + input:cdata(), + self.output:cdata(), + self.weight:cdata(), + self.bias:cdata(), + self.finput:cdata(), + self.fgradInput:cdata(), + self.kW, self.kH, + self.dW, self.dH, + self.padW, self.padH, + self.adjW, self.adjH + ) + + return self.output end function SpatialFullConvolution:updateGradInput(input, gradOutput) @@ -79,15 +92,40 @@ function SpatialFullConvolution:updateGradInput(input, gradOutput) if self.gradInput then input, gradOutput = makeContiguous(self, input, gradOutput) - return input.nn.SpatialFullConvolution_updateGradInput(self, input, gradOutput) + input.THNN.SpatialFullConvolution_updateGradInput( + input:cdata(), + gradOutput:cdata(), + self.gradInput:cdata(), + self.weight:cdata(), + self.finput:cdata(), + self.kW, self.kH, + self.dW, self.dH, + self.padW, self.padH, + self.adjW, self.adjH + ) + + return self.gradInput end end function SpatialFullConvolution:accGradParameters(input, gradOutput, scale) + scale = scale or 1 self:backCompatibility() input, gradOutput = makeContiguous(self, input, gradOutput) - return input.nn.SpatialFullConvolution_accGradParameters(self, input, gradOutput, scale) + input.THNN.SpatialFullConvolution_accGradParameters( + input:cdata(), + gradOutput:cdata(), + self.gradWeight:cdata(), + self.gradBias:cdata(), + self.finput:cdata(), + self.fgradInput:cdata(), + self.kW, self.kH, + self.dW, self.dH, + self.padW, self.padH, + self.adjW, self.adjH, + scale + ) end function SpatialFullConvolution:type(type, tensorCache) diff --git a/SpatialMaxUnpooling.lua b/SpatialMaxUnpooling.lua index 219c556..2d37111 100644 --- a/SpatialMaxUnpooling.lua +++ b/SpatialMaxUnpooling.lua @@ -22,13 +22,24 @@ end function SpatialMaxUnpooling:updateOutput(input) self:setParams() - input.nn.SpatialMaxUnpooling_updateOutput(self, input) + input.THNN.SpatialMaxUnpooling_updateOutput( + input:cdata(), + self.output:cdata(), + self.indices:cdata(), + self.owidth, self.oheight + ) return self.output end function SpatialMaxUnpooling:updateGradInput(input, gradOutput) self:setParams() - input.nn.SpatialMaxUnpooling_updateGradInput(self, input, gradOutput) + input.THNN.SpatialMaxUnpooling_updateGradInput( + input:cdata(), + gradOutput:cdata(), + self.gradInput:cdata(), + self.indices:cdata(), + self.owidth, self.oheight + ) return self.gradInput end diff --git a/SpatialSubSampling.lua b/SpatialSubSampling.lua index 19aa2f5..2aab799 100644 --- a/SpatialSubSampling.lua +++ b/SpatialSubSampling.lua @@ -40,15 +40,40 @@ function SpatialSubSampling:reset(stdv) end function SpatialSubSampling:updateOutput(input) - return input.nn.SpatialSubSampling_updateOutput(self, input) + input.THNN.SpatialSubSampling_updateOutput( + input:cdata(), + self.output:cdata(), + self.weight:cdata(), + self.bias:cdata(), + self.kW, self.kH, + self.dW, self.dH + ) + return self.output end function SpatialSubSampling:updateGradInput(input, gradOutput) if self.gradInput then - return input.nn.SpatialSubSampling_updateGradInput(self, input, gradOutput) + input.THNN.SpatialSubSampling_updateGradInput( + input:cdata(), + gradOutput:cdata(), + self.gradInput:cdata(), + self.weight:cdata(), + self.kW, self.kH, + self.dW, self.dH + ) + return self.gradInput end end function SpatialSubSampling:accGradParameters(input, gradOutput, scale) - return input.nn.SpatialSubSampling_accGradParameters(self, input, gradOutput, scale) + scale = scale or 1 + input.THNN.SpatialSubSampling_accGradParameters( + input:cdata(), + gradOutput:cdata(), + self.gradWeight:cdata(), + self.gradBias:cdata(), + self.kW, self.kH, + self.dW, self.dH, + scale + ) end diff --git a/SpatialUpSamplingNearest.lua b/SpatialUpSamplingNearest.lua index 509a90f..c3b2330 100644 --- a/SpatialUpSamplingNearest.lua +++ b/SpatialUpSamplingNearest.lua @@ -47,12 +47,21 @@ function SpatialUpSamplingNearest:updateOutput(input) else self.output:resize(self.outputSize) end - input.nn.SpatialUpSamplingNearest_updateOutput(self, input) + input.THNN.SpatialUpSamplingNearest_updateOutput( + input:cdata(), + self.output:cdata(), + self.scale_factor + ) return self.output end function SpatialUpSamplingNearest:updateGradInput(input, gradOutput) self.gradInput:resizeAs(input) - input.nn.SpatialUpSamplingNearest_updateGradInput(self, input, gradOutput) + input.THNN.SpatialUpSamplingNearest_updateGradInput( + input:cdata(), + gradOutput:cdata(), + self.gradInput:cdata(), + self.scale_factor + ) return self.gradInput end @@ -470,6 +470,31 @@ TH_API void THNN_(TemporalSubSampling_accGradParameters)( int kW, int dW, real scale); +TH_API void THNN_(SpatialBatchNormalization_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *weight, + THTensor *bias, + THTensor *running_mean, + THTensor *running_var, + THTensor *save_mean, + THTensor *save_std, + bool train, + double momentum, + double eps); +TH_API void THNN_(SpatialBatchNormalization_backward)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *gradWeight, + THTensor *gradBias, + THTensor *weight, + THTensor *save_mean, + THTensor *save_std, + double scale); + TH_API void THNN_(SpatialConvolutionMM_updateOutput)( THNNState *state, THTensor *input, @@ -506,6 +531,47 @@ TH_API void THNN_(SpatialConvolutionMM_accGradParameters)( int padW, int padH, real scale); +TH_API void THNN_(SpatialConvolutionLocal_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *weight, + THTensor *bias, + THTensor *finput, + THTensor *fgradInput, + int kW, int kH, + int dW, int dH, + int padW, int padH, + long inputWidth, long inputHeight, + long outputWidth, long outputHeight); +TH_API void THNN_(SpatialConvolutionLocal_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *weight, + THTensor *finput, + THTensor *fgradInput, + int kW, int kH, + int dW, int dH, + int padW, int padH, + long inputWidth, long inputHeight, + long outputWidth, long outputHeight); +TH_API void THNN_(SpatialConvolutionLocal_accGradParameters)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradWeight, + THTensor *gradBias, + THTensor *finput, + THTensor *fgradInput, + int kW, int kH, + int dW, int dH, + int padW, int padH, + long inputWidth, long inputHeight, + long outputWidth, long outputHeight, + real scale); + TH_API void THNN_(SpatialAdaptiveMaxPooling_updateOutput)( THNNState *state, THTensor *input, @@ -539,6 +605,60 @@ TH_API void THNN_(SpatialAveragePooling_updateGradInput)( bool ceil_mode, bool count_include_pad); +TH_API void THNN_(SpatialFractionalMaxPooling_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + int outputW, int outputH, + int poolSizeW, int poolSizeH, + THTensor *indices, + THTensor *randomSamples); +TH_API void THNN_(SpatialFractionalMaxPooling_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + int outputW, int outputH, + int poolSizeW, int poolSizeH, + THTensor *indices); + +TH_API void THNN_(SpatialFullConvolution_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *weight, + THTensor *bias, + THTensor *columns, + THTensor *ones, + int kW, int kH, + int dW, int dH, + int padW, int padH, + int adjW, int adjH); +TH_API void THNN_(SpatialFullConvolution_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *weight, + THTensor *gradColumns, + int kW, int kH, + int dW, int dH, + int padW, int padH, + int adjW, int adjH); +TH_API void THNN_(SpatialFullConvolution_accGradParameters)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradWeight, + THTensor *gradBias, + THTensor *columns, + THTensor *ones, + int kW, int kH, + int dW, int dH, + int padW, int padH, + int adjW, int adjH, + real scale); + TH_API void THNN_(SpatialMaxPooling_updateOutput)( THNNState *state, THTensor *input, @@ -559,6 +679,58 @@ TH_API void THNN_(SpatialMaxPooling_updateGradInput)( int padW, int padH, bool ceil_mode); +TH_API void THNN_(SpatialMaxUnpooling_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *indices, + int owidth, int oheight); +TH_API void THNN_(SpatialMaxUnpooling_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *indices, + int owidth, int oheight); + +TH_API void THNN_(SpatialSubSampling_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *weight, + THTensor *bias, + int kW, int kH, + int dW, int dH); +TH_API void THNN_(SpatialSubSampling_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *weight, + int kW, int kH, + int dW, int dH); +TH_API void THNN_(SpatialSubSampling_accGradParameters)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradWeight, + THTensor *gradBias, + int kW, int kH, + int dW, int dH, + real scale); + +TH_API void THNN_(SpatialUpSamplingNearest_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + int scale_factor); +TH_API void THNN_(SpatialUpSamplingNearest_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + int scale_factor); + TH_API void THNN_(VolumetricAveragePooling_updateOutput)( THNNState *state, THTensor *input, @@ -745,7 +917,7 @@ ffi.cdef(base_declarations) -- expand macros, allow to use original lines from lib/THNN/generic/THNN.h local preprocessed = string.gsub(generic_THNN_h, 'TH_API void THNN_%(([%a%d_]+)%)', 'void THNN_TYPE%1') -local replacements = +local replacements = { { ['TYPE'] = 'Double', diff --git a/generic/unfold.c b/generic/unfold.c deleted file mode 100644 index 6210399..0000000 --- a/generic/unfold.c +++ /dev/null @@ -1,136 +0,0 @@ -#ifndef TH_GENERIC_FILE -#define TH_GENERIC_FILE "generic/unfold.c" -#else - - -/* note: due to write issues, this one cannot be parallelized as well as unfolded_copy */ -void nn_(unfolded_acc)(THTensor *finput, THTensor *input, - int kW, int kH, int dW, int dH, int padW, int padH, - int nInputPlane, int inputWidth, int inputHeight, - int outputWidth, int outputHeight) -{ -#ifdef _WIN32 - LONG_PTR nip; -#else - size_t nip; -#endif - - real *input_data = THTensor_(data)(input); - real *finput_data = THTensor_(data)(finput); - -#pragma omp parallel for private(nip) - for(nip = 0; nip < nInputPlane; nip++) - { - size_t kw, kh, y, x; - long long ix = 0, iy = 0; - for(kh = 0; kh < kH; kh++) - { - for(kw = 0; kw < kW; kw++) - { - real *src = finput_data + nip*(kH*kW*outputHeight*outputWidth) + kh*(kW*outputHeight*outputWidth) + kw*(outputHeight*outputWidth); - real *dst = input_data + nip*(inputHeight*inputWidth); - if (padW > 0 || padH > 0) { - size_t lpad,rpad; - for(y = 0; y < outputHeight; y++) { - iy = (long long)(y*dH - padH + kh); - if (iy < 0 || iy >= inputHeight) { - } else { - if (dW==1){ - ix = (long long)(0 - padW + kw); - lpad = fmaxf(0,padW-kw); - rpad = fmaxf(0,padW-(kW-kw-1)); - THVector_(add)(dst+(size_t)(iy*inputWidth+ix+lpad), src+(size_t)(y*outputWidth+lpad), 1, outputWidth - lpad - rpad); /* note: THVector_add could handle 1 value better */ - } - else{ - for (x=0; x<outputWidth; x++){ - ix = (long long)(x*dW - padW + kw); - if (ix < 0 || ix >= inputWidth){ - }else - THVector_(add)(dst+(size_t)(iy*inputWidth+ix), src+(size_t)(y*outputWidth+x), 1, 1); - } - } - } - } - } else { - for(y = 0; y < outputHeight; y++) { - iy = (long long)(y*dH + kh); - ix = (long long)(0 + kw); - if (dW == 1 ) - THVector_(add)(dst+(size_t)(iy*inputWidth+ix), src+(size_t)(y*outputWidth), 1, outputWidth); /* note: THVector_add could handle 1 value better */ - else{ - for(x = 0; x < outputWidth; x++) - THVector_(add)(dst+(size_t)(iy*inputWidth+ix+x*dW), src+(size_t)(y*outputWidth+x), 1, 1); - } - } - } - } - } - } -} - - -void nn_(unfolded_copy)(THTensor *finput, THTensor *input, - int kW, int kH, int dW, int dH, int padW, int padH, - int nInputPlane, int inputWidth, int inputHeight, - int outputWidth, int outputHeight) -{ - long k; - real *input_data = THTensor_(data)(input); - real *finput_data = THTensor_(data)(finput); - -#pragma omp parallel for private(k) - for(k = 0; k < nInputPlane*kH*kW; k++) { - size_t nip = k / (kH*kW); - size_t rest = k % (kH*kW); - size_t kh = rest / kW; - size_t kw = rest % kW; - size_t x,y; - long long ix,iy; - real *dst = finput_data + nip*(kH*kW*outputHeight*outputWidth) + kh*(kW*outputHeight*outputWidth) + kw*(outputHeight*outputWidth); - real *src = input_data + nip*(inputHeight*inputWidth); - if (padW > 0 || padH > 0) { - size_t lpad,rpad; - for(y = 0; y < outputHeight; y++) { - iy = (long long)(y*dH - padH + kh); - if (iy < 0 || iy >= inputHeight) { - memset(dst+y*outputWidth, 0, sizeof(real)*outputWidth); - } else { - if (dW==1){ - ix = (long long)(0 - padW + kw); - lpad = fmaxf(0,padW-kw); - rpad = fmaxf(0,padW-(kW-kw-1)); - if (outputWidth-rpad-lpad <= 0) { - memset(dst+(size_t)(y*outputWidth), 0, sizeof(real)*outputWidth); - } else { - if (lpad > 0) memset(dst+y*outputWidth, 0, sizeof(real)*lpad); - memcpy(dst+(size_t)(y*outputWidth+lpad), src+(size_t)(iy*inputWidth+ix+lpad), sizeof(real)*(outputWidth-rpad-lpad)); - if (rpad > 0) memset(dst+y*outputWidth + outputWidth - rpad, 0, sizeof(real)*rpad); - } - } - else{ - for (x=0; x<outputWidth; x++){ - ix = (long long)(x*dW - padW + kw); - if (ix < 0 || ix >= inputWidth) - memset(dst+(size_t)(y*outputWidth+x), 0, sizeof(real)*1); - else - memcpy(dst+(size_t)(y*outputWidth+x), src+(size_t)(iy*inputWidth+ix), sizeof(real)*(1)); - } - } - } - } - } else { - for(y = 0; y < outputHeight; y++) { - iy = (long long)(y*dH + kh); - ix = (long long)(0 + kw); - if (dW == 1) - memcpy(dst+(size_t)(y*outputWidth), src+(size_t)(iy*inputWidth+ix), sizeof(real)*outputWidth); - else{ - for (x=0; x<outputWidth; x++) - memcpy(dst+(size_t)(y*outputWidth+x), src+(size_t)(iy*inputWidth+ix+x*dW), sizeof(real)*(1)); - } - } - } - } -} - -#endif
\ No newline at end of file diff --git a/generic/unfold.h b/generic/unfold.h deleted file mode 100644 index 928ec50..0000000 --- a/generic/unfold.h +++ /dev/null @@ -1,15 +0,0 @@ -#ifndef TH_GENERIC_FILE -#define TH_GENERIC_FILE "generic/unfold.h" -#else - - -void nn_(unfolded_acc)(THTensor *finput, THTensor *input, - int kW, int kH, int dW, int dH, int padW, int padH, - int nInputPlane, int inputWidth, int inputHeight, - int outputWidth, int outputHeight); - -void nn_(unfolded_copy)(THTensor *finput, THTensor *input, - int kW, int kH, int dW, int dH, int padW, int padH, - int nInputPlane, int inputWidth, int inputHeight, - int outputWidth, int outputHeight); -#endif
\ No newline at end of file @@ -5,39 +5,16 @@ #define torch_Tensor TH_CONCAT_STRING_3(torch.,Real,Tensor) #define nn_(NAME) TH_CONCAT_3(nn_, Real, NAME) -#include "generic/SpatialBatchNormalization.c" -#include "THGenerateFloatTypes.h" - -#include "generic/unfold.c" -#include "THGenerateFloatTypes.h" #include "generic/SpatialConvolution.c" #include "THGenerateFloatTypes.h" -#include "generic/SpatialConvolutionLocal.c" -#include "THGenerateFloatTypes.h" - -#include "generic/SpatialFullConvolution.c" -#include "THGenerateFloatTypes.h" - #include "generic/SpatialFullConvolutionMap.c" #include "THGenerateFloatTypes.h" #include "generic/SpatialConvolutionMap.c" #include "THGenerateFloatTypes.h" -#include "generic/SpatialSubSampling.c" -#include "THGenerateFloatTypes.h" - -#include "generic/SpatialMaxUnpooling.c" -#include "THGenerateFloatTypes.h" - -#include "generic/SpatialFractionalMaxPooling.c" -#include "THGenerateFloatTypes.h" - -#include "generic/SpatialUpSamplingNearest.c" -#include "THGenerateFloatTypes.h" - LUA_EXTERNC DLL_EXPORT int luaopen_libnn(lua_State *L); int luaopen_libnn(lua_State *L) @@ -46,28 +23,13 @@ int luaopen_libnn(lua_State *L) lua_pushvalue(L, -1); lua_setglobal(L, "nn"); - nn_FloatSpatialBatchNormalization_init(L); nn_FloatSpatialConvolution_init(L); - nn_FloatSpatialConvolutionLocal_init(L); - nn_FloatSpatialFullConvolution_init(L); nn_FloatSpatialFullConvolutionMap_init(L); nn_FloatSpatialConvolutionMap_init(L); - nn_FloatSpatialSubSampling_init(L); - nn_FloatSpatialMaxUnpooling_init(L); - nn_FloatSpatialFractionalMaxPooling_init(L); - nn_FloatSpatialUpSamplingNearest_init(L); - nn_DoubleSpatialBatchNormalization_init(L); - nn_DoubleSpatialMaxUnpooling_init(L); nn_DoubleSpatialConvolution_init(L); - nn_DoubleSpatialConvolutionLocal_init(L); - nn_DoubleSpatialFullConvolution_init(L); nn_DoubleSpatialFullConvolutionMap_init(L); - nn_DoubleSpatialFullConvolution_init(L); nn_DoubleSpatialConvolutionMap_init(L); - nn_DoubleSpatialSubSampling_init(L); - nn_DoubleSpatialFractionalMaxPooling_init(L); - nn_DoubleSpatialUpSamplingNearest_init(L); return 1; } diff --git a/lib/THNN/generic/SpatialBatchNormalization.c b/lib/THNN/generic/SpatialBatchNormalization.c index 25171c6..bf3108b 100644 --- a/lib/THNN/generic/SpatialBatchNormalization.c +++ b/lib/THNN/generic/SpatialBatchNormalization.c @@ -2,20 +2,8 @@ #define TH_GENERIC_FILE "generic/SpatialBatchNormalization.c" #else -static int nn_(SpatialBatchNormalization_updateOutput)(lua_State *L) +void THNN_(SpatialBatchNormalization_updateOutput)(THNNState *state, THTensor *input, THTensor *output, THTensor *weight, THTensor *bias, THTensor *running_mean, THTensor *running_var, THTensor *save_mean, THTensor *save_std, bool train, double momentum, double eps) { - THTensor *input = luaT_checkudata(L, 1, torch_Tensor); - THTensor *output = luaT_checkudata(L, 2, torch_Tensor); - THTensor *weight = luaT_toudata(L, 3, torch_Tensor); - THTensor *bias = luaT_toudata(L, 4, torch_Tensor); - int train = lua_toboolean(L, 5); - double eps = lua_tonumber(L, 6); - double momentum = lua_tonumber(L, 7); - THTensor *running_mean = luaT_checkudata(L, 8, torch_Tensor); - THTensor *running_var = luaT_checkudata(L, 9, torch_Tensor); - THTensor *save_mean = luaT_toudata(L, 10, torch_Tensor); - THTensor *save_std = luaT_toudata(L, 11, torch_Tensor); - long nBatch = THTensor_(size)(input, 0); long nFeature = THTensor_(size)(input, 1); long iH = THTensor_(size)(input, 2); @@ -71,22 +59,10 @@ static int nn_(SpatialBatchNormalization_updateOutput)(lua_State *L) THTensor_(free)(out); THTensor_(free)(in); } - - return 0; } -static int nn_(SpatialBatchNormalization_backward)(lua_State *L) +void THNN_(SpatialBatchNormalization_backward)(THNNState *state, THTensor *input, THTensor *gradOutput, THTensor *gradInput, THTensor *gradWeight, THTensor *gradBias, THTensor *weight, THTensor *save_mean, THTensor *save_std, double scale) { - THTensor *input = luaT_checkudata(L, 1, torch_Tensor); - THTensor *gradOutput = luaT_checkudata(L, 2, torch_Tensor); - THTensor *gradInput = luaT_toudata(L, 3, torch_Tensor); - THTensor *gradWeight = luaT_toudata(L, 4, torch_Tensor); - THTensor *gradBias = luaT_toudata(L, 5, torch_Tensor); - THTensor *weight = luaT_toudata(L, 6, torch_Tensor); - THTensor *save_mean = luaT_toudata(L, 7, torch_Tensor); - THTensor *save_std = luaT_toudata(L, 8, torch_Tensor); - double scale = lua_tonumber(L, 9); - long nBatch = THTensor_(size)(input, 0); long nFeature = THTensor_(size)(input, 1); long iH = THTensor_(size)(input, 2); @@ -142,21 +118,6 @@ static int nn_(SpatialBatchNormalization_backward)(lua_State *L) THTensor_(free)(gradOut); THTensor_(free)(in); } - - return 0; -} - -static const struct luaL_Reg nn_(SpatialBatchNormalization__) [] = { - {"SpatialBatchNormalization_updateOutput", nn_(SpatialBatchNormalization_updateOutput)}, - {"SpatialBatchNormalization_backward", nn_(SpatialBatchNormalization_backward)}, - {NULL, NULL} -}; - -static void nn_(SpatialBatchNormalization_init)(lua_State *L) -{ - luaT_pushmetatable(L, torch_Tensor); - luaT_registeratname(L, nn_(SpatialBatchNormalization__), "nn"); - lua_pop(L,1); } #endif diff --git a/lib/THNN/generic/SpatialConvolutionLocal.c b/lib/THNN/generic/SpatialConvolutionLocal.c index 6377ecd..091c6f0 100644 --- a/lib/THNN/generic/SpatialConvolutionLocal.c +++ b/lib/THNN/generic/SpatialConvolutionLocal.c @@ -2,14 +2,8 @@ #define TH_GENERIC_FILE "generic/SpatialConvolutionLocal.c" #else -#ifdef _WIN32 -# include <windows.h> -#endif - -#include "unfold.h" - -static void nn_(SpatialConvolutionLocal_updateOutput_frame)(THTensor *input, THTensor *output, THTensor *weight, THTensor *bias, THTensor *finput, +static void THNN_(SpatialConvolutionLocal_updateOutput_frame)(THTensor *input, THTensor *output, THTensor *weight, THTensor *bias, THTensor *finput, int kW, int kH, int dW, int dH, int padW, int padH, long nInputPlane, long inputWidth, long inputHeight, long nOutputPlane, long outputWidth, long outputHeight) @@ -17,7 +11,7 @@ static void nn_(SpatialConvolutionLocal_updateOutput_frame)(THTensor *input, THT long i; THTensor *output3d, *finput3d; - nn_(unfolded_copy)(finput, input, kW, kH, dW, dH, padW, padH, nInputPlane, inputWidth, inputHeight, outputWidth, outputHeight); + THNN_(unfolded_copy)(finput, input, kW, kH, dW, dH, padW, padH, nInputPlane, inputWidth, inputHeight, outputWidth, outputHeight); THTensor_(copy)(output, bias); @@ -39,33 +33,29 @@ static void nn_(SpatialConvolutionLocal_updateOutput_frame)(THTensor *input, THT THTensor_(free)(finput3d); } -static int nn_(SpatialConvolutionLocal_updateOutput)(lua_State *L) +void THNN_(SpatialConvolutionLocal_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *weight, + THTensor *bias, + THTensor *finput, + THTensor *fgradInput, + int kW, int kH, + int dW, int dH, + int padW, int padH, + long inputWidth, long inputHeight, + long outputWidth, long outputHeight) { - THTensor *input = luaT_checkudata(L, 2, torch_Tensor); - long inputWidth = luaT_getfieldcheckint(L, 1, "iW"); - long inputHeight = luaT_getfieldcheckint(L, 1, "iH"); - long outputWidth = luaT_getfieldcheckint(L, 1, "oW"); - long outputHeight = luaT_getfieldcheckint(L, 1, "oH"); - int kW = luaT_getfieldcheckint(L, 1, "kW"); - int kH = luaT_getfieldcheckint(L, 1, "kH"); - int dW = luaT_getfieldcheckint(L, 1, "dW"); - int dH = luaT_getfieldcheckint(L, 1, "dH"); - int padW = luaT_getfieldcheckint(L, 1, "padW"); - int padH = luaT_getfieldcheckint(L, 1, "padH"); - long nInputPlane = luaT_getfieldcheckint(L, 1, "nInputPlane"); - long nOutputPlane = luaT_getfieldcheckint(L, 1, "nOutputPlane"); - - THTensor *finput = luaT_getfieldcheckudata(L, 1, "finput", torch_Tensor); - THTensor *weight = luaT_getfieldcheckudata(L, 1, "weight", torch_Tensor); - THTensor *bias = luaT_getfieldcheckudata(L, 1, "bias", torch_Tensor); - THTensor *output = luaT_getfieldcheckudata(L, 1, "output", torch_Tensor); + long nInputPlane = THTensor_(size)(weight,2)/(kW*kH); + long nOutputPlane = THTensor_(size)(weight,1); if(input->nDimension == 3) { THTensor_(resize2d)(finput, kW*kH*nInputPlane, outputHeight*outputWidth); THTensor_(resize3d)(output, nOutputPlane, outputHeight, outputWidth); - nn_(SpatialConvolutionLocal_updateOutput_frame)(input, output, weight, bias, finput, + THNN_(SpatialConvolutionLocal_updateOutput_frame)(input, output, weight, bias, finput, kW, kH, dW, dH, padW, padH, nInputPlane, inputWidth, inputHeight, nOutputPlane, outputWidth, outputHeight); @@ -85,7 +75,7 @@ static int nn_(SpatialConvolutionLocal_updateOutput)(lua_State *L) THTensor *output_t = THTensor_(newSelect)(output, 0, t); THTensor *finput_t = THTensor_(newSelect)(finput, 0, t); - nn_(SpatialConvolutionLocal_updateOutput_frame)(input_t, output_t, weight, bias, finput_t, + THNN_(SpatialConvolutionLocal_updateOutput_frame)(input_t, output_t, weight, bias, finput_t, kW, kH, dW, dH, padW, padH, nInputPlane, inputWidth, inputHeight, nOutputPlane, outputWidth, outputHeight); @@ -95,12 +85,10 @@ static int nn_(SpatialConvolutionLocal_updateOutput)(lua_State *L) THTensor_(free)(finput_t); } } - - return 1; } -static void nn_(SpatialConvolutionLocal_updateGradInput_frame)(THTensor *gradInput, THTensor *gradOutput, THTensor *weight, THTensor *fgradInput, +static void THNN_(SpatialConvolutionLocal_updateGradInput_frame)(THTensor *gradInput, THTensor *gradOutput, THTensor *weight, THTensor *fgradInput, int kW, int kH, int dW, int dH, int padW, int padH, long nInputPlane, long inputWidth, long inputHeight, long nOutputPlane, long outputWidth, long outputHeight) @@ -124,31 +112,26 @@ static void nn_(SpatialConvolutionLocal_updateGradInput_frame)(THTensor *gradInp THTensor_(zero)(gradInput); - nn_(unfolded_acc)(fgradInput, gradInput, kW, kH, dW, dH, padW, padH, + THNN_(unfolded_acc)(fgradInput, gradInput, kW, kH, dW, dH, padW, padH, nInputPlane, inputWidth, inputHeight, outputWidth, outputHeight); } -static int nn_(SpatialConvolutionLocal_updateGradInput)(lua_State *L) +void THNN_(SpatialConvolutionLocal_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *weight, + THTensor *finput, + THTensor *fgradInput, + int kW, int kH, + int dW, int dH, + int padW, int padH, + long inputWidth, long inputHeight, + long outputWidth, long outputHeight) { - THTensor *input = luaT_checkudata(L, 2, torch_Tensor); - THTensor *gradOutput = luaT_checkudata(L, 3, torch_Tensor); - long inputWidth = luaT_getfieldcheckint(L, 1, "iW"); - long inputHeight = luaT_getfieldcheckint(L, 1, "iH"); - long outputWidth = luaT_getfieldcheckint(L, 1, "oW"); - long outputHeight = luaT_getfieldcheckint(L, 1, "oH"); - int kW = luaT_getfieldcheckint(L, 1, "kW"); - int kH = luaT_getfieldcheckint(L, 1, "kH"); - int dW = luaT_getfieldcheckint(L, 1, "dW"); - int dH = luaT_getfieldcheckint(L, 1, "dH"); - int padW = luaT_getfieldcheckint(L, 1, "padW"); - int padH = luaT_getfieldcheckint(L, 1, "padH"); - long nInputPlane = luaT_getfieldcheckint(L, 1, "nInputPlane"); - long nOutputPlane = luaT_getfieldcheckint(L, 1, "nOutputPlane"); - - THTensor *finput = luaT_getfieldcheckudata(L, 1, "finput", torch_Tensor); - THTensor *fgradInput = luaT_getfieldcheckudata(L, 1, "fgradInput", torch_Tensor); - THTensor *weight = luaT_getfieldcheckudata(L, 1, "weight", torch_Tensor); - THTensor *gradInput = luaT_getfieldcheckudata(L, 1, "gradInput", torch_Tensor); + long nInputPlane = THTensor_(size)(weight,2)/(kW*kH); + long nOutputPlane = THTensor_(size)(weight,1); THTensor_(resizeAs)(gradInput, input); THTensor_(resizeAs)(fgradInput, finput); @@ -156,7 +139,7 @@ static int nn_(SpatialConvolutionLocal_updateGradInput)(lua_State *L) if(input->nDimension == 3) { - nn_(SpatialConvolutionLocal_updateGradInput_frame)(gradInput, gradOutput, weight, fgradInput, kW, kH, dW, dH, padW, padH, + THNN_(SpatialConvolutionLocal_updateGradInput_frame)(gradInput, gradOutput, weight, fgradInput, kW, kH, dW, dH, padW, padH, nInputPlane, inputWidth, inputHeight, nOutputPlane, outputWidth, outputHeight); } @@ -172,7 +155,7 @@ static int nn_(SpatialConvolutionLocal_updateGradInput)(lua_State *L) THTensor *gradOutput_t = THTensor_(newSelect)(gradOutput, 0, t); THTensor *fgradInput_t = THTensor_(newSelect)(fgradInput, 0, t); - nn_(SpatialConvolutionLocal_updateGradInput_frame)(gradInput_t, gradOutput_t, weight, fgradInput_t, kW, kH, dW, dH, padW, padH, + THNN_(SpatialConvolutionLocal_updateGradInput_frame)(gradInput_t, gradOutput_t, weight, fgradInput_t, kW, kH, dW, dH, padW, padH, nInputPlane, inputWidth, inputHeight, nOutputPlane, outputWidth, outputHeight); @@ -183,11 +166,9 @@ static int nn_(SpatialConvolutionLocal_updateGradInput)(lua_State *L) } THTensor_(transpose)(weight, weight, 1, 2); - - return 1; } -static void nn_(SpatialConvolutionLocal_accGradParameters_frame)(THTensor *gradOutput, THTensor *gradWeight, THTensor *gradBias, THTensor *finput, real scale, +static void THNN_(SpatialConvolutionLocal_accGradParameters_frame)(THTensor *gradOutput, THTensor *gradWeight, THTensor *gradBias, THTensor *finput, real scale, int kW, int kH, int dW, int dH, int padW, int padH, long nInputPlane, long inputWidth, long inputHeight, long nOutputPlane, long outputWidth, long outputHeight) @@ -213,31 +194,27 @@ static void nn_(SpatialConvolutionLocal_accGradParameters_frame)(THTensor *gradO THTensor_(free)(finput3d); } -static int nn_(SpatialConvolutionLocal_accGradParameters)(lua_State *L) +void THNN_(SpatialConvolutionLocal_accGradParameters)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradWeight, + THTensor *gradBias, + THTensor *finput, + THTensor *fgradInput, + int kW, int kH, + int dW, int dH, + int padW, int padH, + long inputWidth, long inputHeight, + long outputWidth, long outputHeight, + real scale) { - THTensor *input = luaT_checkudata(L, 2, torch_Tensor); - THTensor *gradOutput = luaT_checkudata(L, 3, torch_Tensor); - real scale = luaL_optnumber(L, 4, 1); - long inputWidth = luaT_getfieldcheckint(L, 1, "iW"); - long inputHeight = luaT_getfieldcheckint(L, 1, "iH"); - long outputWidth = luaT_getfieldcheckint(L, 1, "oW"); - long outputHeight = luaT_getfieldcheckint(L, 1, "oH"); - int kW = luaT_getfieldcheckint(L, 1, "kW"); - int kH = luaT_getfieldcheckint(L, 1, "kH"); - int dW = luaT_getfieldcheckint(L, 1, "dW"); - int dH = luaT_getfieldcheckint(L, 1, "dH"); - int padW = luaT_getfieldcheckint(L, 1, "padW"); - int padH = luaT_getfieldcheckint(L, 1, "padH"); - long nInputPlane = luaT_getfieldcheckint(L, 1, "nInputPlane"); - long nOutputPlane = luaT_getfieldcheckint(L, 1, "nOutputPlane"); - - THTensor *finput = luaT_getfieldcheckudata(L, 1, "finput", torch_Tensor); - THTensor *gradWeight = luaT_getfieldcheckudata(L, 1, "gradWeight", torch_Tensor); - THTensor *gradBias = luaT_getfieldcheckudata(L, 1, "gradBias", torch_Tensor); + long nInputPlane = THTensor_(size)(gradWeight,2)/(kW*kH); + long nOutputPlane = THTensor_(size)(gradWeight,1); if(input->nDimension == 3) { - nn_(SpatialConvolutionLocal_accGradParameters_frame)(gradOutput, gradWeight, gradBias, finput, scale, kW, kH, dW, dH, padW, padH, + THNN_(SpatialConvolutionLocal_accGradParameters_frame)(gradOutput, gradWeight, gradBias, finput, scale, kW, kH, dW, dH, padW, padH, nInputPlane, inputWidth, inputHeight, nOutputPlane, outputWidth, outputHeight); } @@ -251,7 +228,7 @@ static int nn_(SpatialConvolutionLocal_accGradParameters)(lua_State *L) THTensor *gradOutput_t = THTensor_(newSelect)(gradOutput, 0, t); THTensor *finput_t = THTensor_(newSelect)(finput, 0, t); - nn_(SpatialConvolutionLocal_accGradParameters_frame)(gradOutput_t, gradWeight, gradBias, finput_t, scale, kW, kH, dW, dH, padW, padH, + THNN_(SpatialConvolutionLocal_accGradParameters_frame)(gradOutput_t, gradWeight, gradBias, finput_t, scale, kW, kH, dW, dH, padW, padH, nInputPlane, inputWidth, inputHeight, nOutputPlane, outputWidth, outputHeight); @@ -259,22 +236,6 @@ static int nn_(SpatialConvolutionLocal_accGradParameters)(lua_State *L) THTensor_(free)(finput_t); } } - - return 0; -} - -static const struct luaL_Reg nn_(SpatialConvolutionLocal__) [] = { - {"SpatialConvolutionLocal_updateOutput", nn_(SpatialConvolutionLocal_updateOutput)}, - {"SpatialConvolutionLocal_updateGradInput", nn_(SpatialConvolutionLocal_updateGradInput)}, - {"SpatialConvolutionLocal_accGradParameters", nn_(SpatialConvolutionLocal_accGradParameters)}, - {NULL, NULL} -}; - -static void nn_(SpatialConvolutionLocal_init)(lua_State *L) -{ - luaT_pushmetatable(L, torch_Tensor); - luaT_registeratname(L, nn_(SpatialConvolutionLocal__), "nn"); - lua_pop(L,1); } #endif diff --git a/lib/THNN/generic/SpatialFractionalMaxPooling.c b/lib/THNN/generic/SpatialFractionalMaxPooling.c index f90f92a..1c2b6ab 100644 --- a/lib/THNN/generic/SpatialFractionalMaxPooling.c +++ b/lib/THNN/generic/SpatialFractionalMaxPooling.c @@ -2,7 +2,7 @@ #define TH_GENERIC_FILE "generic/SpatialFractionalMaxPooling.c" #else -static long* nn_(SpatialFractionalMaxPooling_generateIntervals)( +static long* THNN_(SpatialFractionalMaxPooling_generateIntervals)( real sample, long inputSize, long outputSize, @@ -20,7 +20,7 @@ static long* nn_(SpatialFractionalMaxPooling_generateIntervals)( return sequence; } -static void nn_(SpatialFractionalMaxPooling_updateOutput_frame)( +static void THNN_(SpatialFractionalMaxPooling_updateOutput_frame)( real* input, real* output, real* indices, @@ -37,10 +37,10 @@ static void nn_(SpatialFractionalMaxPooling_updateOutput_frame)( /* Generate interval sequence */ long* sequenceW = - nn_(SpatialFractionalMaxPooling_generateIntervals)( + THNN_(SpatialFractionalMaxPooling_generateIntervals)( randomSamplesForPlane[0], inputW, outputW, poolSizeW); long* sequenceH = - nn_(SpatialFractionalMaxPooling_generateIntervals)( + THNN_(SpatialFractionalMaxPooling_generateIntervals)( randomSamplesForPlane[1], inputH, outputH, poolSizeH); /* loop over output */ @@ -88,24 +88,23 @@ static void nn_(SpatialFractionalMaxPooling_updateOutput_frame)( } } -static int nn_(SpatialFractionalMaxPooling_updateOutput)(lua_State *L) { - THTensor* output = luaT_checkudata(L, 1, torch_Tensor); - THTensor* input = luaT_checkudata(L, 2, torch_Tensor); - int outputW = luaL_checknumber(L, 3); - int outputH = luaL_checknumber(L, 4); - int poolSizeW = luaL_checknumber(L, 5); - int poolSizeH = luaL_checknumber(L, 6); - THTensor* indices = luaT_checkudata(L, 7, torch_Tensor); - THTensor* randomSamples = luaT_checkudata(L, 8, torch_Tensor); - +void THNN_(SpatialFractionalMaxPooling_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + int outputW, int outputH, + int poolSizeW, int poolSizeH, + THTensor *indices, + THTensor *randomSamples) { + long numBatch = 1; int planeDim = 0; int heightDim = 1; int widthDim = 2; long numInputDims = THTensor_(nDimension)(input); - luaL_argcheck(L, numInputDims == 3 || numInputDims == 4, 2, - "3D or 4D (batch mode) tensor expected"); + THArgCheck(numInputDims == 3 || numInputDims == 4, 2, + "3D or 4D (batch mode) tensor expected"); if (numInputDims == 4) { numBatch = THTensor_(size)(input, 0); @@ -119,10 +118,10 @@ static int nn_(SpatialFractionalMaxPooling_updateOutput)(lua_State *L) { long inputH = THTensor_(size)(input, heightDim); long inputW = THTensor_(size)(input, widthDim); - luaL_argcheck(L, outputH + poolSizeH - 1 < inputH, 6, - "poolSizeH too large relative to input height"); - luaL_argcheck(L, outputW + poolSizeW - 1 < inputW, 5, - "poolSizeW too large relative to input width"); + THArgCheck(outputH + poolSizeH - 1 < inputH, 7, + "poolSizeH too large relative to input height"); + THArgCheck(outputW + poolSizeW - 1 < inputW, 6, + "poolSizeW too large relative to input width"); /* get contiguous input */ input = THTensor_(newContiguous)(input); @@ -133,7 +132,7 @@ static int nn_(SpatialFractionalMaxPooling_updateOutput)(lua_State *L) { /* indices will contain the locations for each output point */ THTensor_(resize3d)(indices, numPlanes, outputH, outputW); - nn_(SpatialFractionalMaxPooling_updateOutput_frame)( + THNN_(SpatialFractionalMaxPooling_updateOutput_frame)( THTensor_(data)(input), THTensor_(data)(output), THTensor_(data)(indices), @@ -147,7 +146,7 @@ static int nn_(SpatialFractionalMaxPooling_updateOutput)(lua_State *L) { long batch; #pragma omp parallel for private(batch) for (batch = 0; batch < numBatch; ++batch) { - nn_(SpatialFractionalMaxPooling_updateOutput_frame)( + THNN_(SpatialFractionalMaxPooling_updateOutput_frame)( THTensor_(data)(input) + batch * numPlanes * inputH * inputW, THTensor_(data)(output) + batch * numPlanes * outputH * outputW, THTensor_(data)(indices) + batch * numPlanes * outputH * outputW, @@ -158,11 +157,9 @@ static int nn_(SpatialFractionalMaxPooling_updateOutput)(lua_State *L) { /* cleanup */ THTensor_(free)(input); - - return 0; } -static void nn_(SpatialFractionalMaxPooling_updateGradInput_frame)( +static void THNN_(SpatialFractionalMaxPooling_updateGradInput_frame)( real* gradInput, real* gradOutput, real* indices, @@ -189,15 +186,14 @@ static void nn_(SpatialFractionalMaxPooling_updateGradInput_frame)( } } -static int nn_(SpatialFractionalMaxPooling_updateGradInput)(lua_State *L) { - THTensor* gradInput = luaT_checkudata(L, 1, torch_Tensor); - THTensor* input = luaT_checkudata(L, 2, torch_Tensor); - THTensor* gradOutput = luaT_checkudata(L, 3, torch_Tensor); - long outputW = luaL_checknumber(L, 4); - long outputH = luaL_checknumber(L, 5); - int poolSizeW = luaL_checknumber(L, 6); - int poolSizeH = luaL_checknumber(L, 7); - THTensor* indices = luaT_checkudata(L, 8, torch_Tensor); +void THNN_(SpatialFractionalMaxPooling_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + int outputW, int outputH, + int poolSizeW, int poolSizeH, + THTensor *indices) { long numBatch = 1; int planeDim = 0; @@ -217,10 +213,10 @@ static int nn_(SpatialFractionalMaxPooling_updateGradInput)(lua_State *L) { long inputH = THTensor_(size)(input, heightDim); long inputW = THTensor_(size)(input, widthDim); - luaL_argcheck(L, outputW == THTensor_(size)(gradOutput, widthDim), 3, - "gradOutput width unexpected"); - luaL_argcheck(L, outputH == THTensor_(size)(gradOutput, heightDim), 3, - "gradOutput height unexpected"); + THArgCheck(outputW == THTensor_(size)(gradOutput, widthDim), 3, + "gradOutput width unexpected"); + THArgCheck(outputH == THTensor_(size)(gradOutput, heightDim), 3, + "gradOutput height unexpected"); /* get contiguous gradOutput */ gradOutput = THTensor_(newContiguous)(gradOutput); @@ -231,7 +227,7 @@ static int nn_(SpatialFractionalMaxPooling_updateGradInput)(lua_State *L) { /* backprop */ if (numInputDims == 3) { - nn_(SpatialFractionalMaxPooling_updateGradInput_frame)( + THNN_(SpatialFractionalMaxPooling_updateGradInput_frame)( THTensor_(data)(gradInput), THTensor_(data)(gradOutput), THTensor_(data)(indices), @@ -240,7 +236,7 @@ static int nn_(SpatialFractionalMaxPooling_updateGradInput)(lua_State *L) { long batch; #pragma omp parallel for private(batch) for (batch = 0; batch < numBatch; ++batch) { - nn_(SpatialFractionalMaxPooling_updateGradInput_frame)( + THNN_(SpatialFractionalMaxPooling_updateGradInput_frame)( THTensor_(data)(gradInput) + batch * numPlanes * inputH * inputW, THTensor_(data)(gradOutput) + batch * numPlanes * outputH * outputW, THTensor_(data)(indices) + batch * numPlanes * outputH * outputW, @@ -250,21 +246,6 @@ static int nn_(SpatialFractionalMaxPooling_updateGradInput)(lua_State *L) { /* cleanup */ THTensor_(free)(gradOutput); - - return 0; -} - -static const struct luaL_Reg nn_(SpatialFractionalMaxPooling__) [] = { - {"SpatialFractionalMaxPooling_updateOutput", nn_(SpatialFractionalMaxPooling_updateOutput)}, - {"SpatialFractionalMaxPooling_updateGradInput", nn_(SpatialFractionalMaxPooling_updateGradInput)}, - {NULL, NULL} -}; - -static void nn_(SpatialFractionalMaxPooling_init)(lua_State *L) -{ - luaT_pushmetatable(L, torch_Tensor); - luaT_registeratname(L, nn_(SpatialFractionalMaxPooling__), "nn"); - lua_pop(L,1); } #endif diff --git a/lib/THNN/generic/SpatialFullConvolution.c b/lib/THNN/generic/SpatialFullConvolution.c index 9641792..de2c18f 100644 --- a/lib/THNN/generic/SpatialFullConvolution.c +++ b/lib/THNN/generic/SpatialFullConvolution.c @@ -3,7 +3,7 @@ #else -static void nn_(im2col)(const real* data_im, const int channels, +static void THNN_(im2col)(const real* data_im, const int channels, const int height, const int width, const int kernel_h, const int kernel_w, const int pad_h, const int pad_w, const int stride_h, const int stride_w, @@ -30,7 +30,7 @@ static void nn_(im2col)(const real* data_im, const int channels, } } -static void nn_(col2im)(const real* data_col, const int channels, +static void THNN_(col2im)(const real* data_col, const int channels, const int height, const int width, const int patch_h, const int patch_w, const int pad_h, const int pad_w, const int stride_h, const int stride_w, @@ -56,38 +56,32 @@ static void nn_(col2im)(const real* data_col, const int channels, } } -static int nn_(SpatialFullConvolution_updateOutput)(lua_State *L) { - // Input - THTensor *input = (THTensor*)luaT_checkudata(L, 2, torch_Tensor); - - // Params: - int dW = luaT_getfieldcheckint(L, 1, "dW"); - int dH = luaT_getfieldcheckint(L, 1, "dH"); - int kW = luaT_getfieldcheckint(L, 1, "kW"); - int kH = luaT_getfieldcheckint(L, 1, "kH"); - int nInputPlane = luaT_getfieldcheckint(L, 1, "nInputPlane"); - int nOutputPlane = luaT_getfieldcheckint(L, 1, "nOutputPlane"); - int padW = luaT_getfieldcheckint(L, 1, "padW"); - int padH = luaT_getfieldcheckint(L, 1, "padH"); - int adjW = luaT_getfieldcheckint(L, 1, "adjW"); - int adjH = luaT_getfieldcheckint(L, 1, "adjH"); - - THTensor *weight = (THTensor*)luaT_getfieldcheckudata(L, 1, "weight", torch_Tensor); - THTensor *bias = (THTensor*)luaT_getfieldcheckudata(L, 1, "bias", torch_Tensor); - THTensor *columns = (THTensor*)luaT_getfieldcheckudata(L, 1, "finput", torch_Tensor); - THTensor *ones = (THTensor*)luaT_getfieldcheckudata(L, 1, "fgradInput", torch_Tensor); - THTensor *output = (THTensor*)luaT_getfieldcheckudata(L, 1, "output", torch_Tensor); - - luaL_argcheck(L, input->nDimension == 3 || input->nDimension == 4, 2, "3D or 4D (batch mode) tensor is expected"); +void THNN_(SpatialFullConvolution_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *weight, + THTensor *bias, + THTensor *columns, + THTensor *ones, + int kW, int kH, + int dW, int dH, + int padW, int padH, + int adjW, int adjH) +{ + int nInputPlane = THTensor_(size)(weight,0); + int nOutputPlane = THTensor_(size)(weight,1); + + THArgCheck(input->nDimension == 3 || input->nDimension == 4, 2, "3D or 4D (batch mode) tensor is expected"); int batch = 1; if (input->nDimension == 3) { - luaL_argcheck(L, input->size[0] == nInputPlane, 2, "input channels and nInputPlane dont match"); + THArgCheck(input->size[0] == nInputPlane, 2, "input channels and nInputPlane dont match"); // Force batch batch = 0; THTensor_(resize4d)(input, 1, input->size[0], input->size[1], input->size[2]); } else { - luaL_argcheck(L, input->size[1] == nInputPlane, 2, "input channels and nInputPlane dont match"); + THArgCheck(input->size[1] == nInputPlane, 2, "input channels and nInputPlane dont match"); } long inputWidth = input->size[3]; @@ -142,7 +136,7 @@ static int nn_(SpatialFullConvolution_updateOutput)(lua_State *L) { ); // Unpack columns back into input: - nn_(col2im)( + THNN_(col2im)( THTensor_(data)(columns), nOutputPlane, outputHeight, outputWidth, kH, kW, padH, padW, dH, dW, THTensor_(data)(output_n) @@ -177,33 +171,24 @@ static int nn_(SpatialFullConvolution_updateOutput)(lua_State *L) { THTensor_(resize3d)(output, nOutputPlane, outputHeight, outputWidth); THTensor_(resize3d)(input, nInputPlane, inputHeight, inputWidth); } - - // return output - return 1; } -static int nn_(SpatialFullConvolution_updateGradInput)(lua_State *L) { - // Inputs - THTensor *input = (THTensor *)luaT_checkudata(L, 2, torch_Tensor); - THTensor *gradOutput = (THTensor *)luaT_checkudata(L, 3, torch_Tensor); - - // Params - int dW = luaT_getfieldcheckint(L, 1, "dW"); - int dH = luaT_getfieldcheckint(L, 1, "dH"); - int kW = luaT_getfieldcheckint(L, 1, "kW"); - int kH = luaT_getfieldcheckint(L, 1, "kH"); - int nInputPlane = luaT_getfieldcheckint(L, 1, "nInputPlane"); - int nOutputPlane = luaT_getfieldcheckint(L, 1, "nOutputPlane"); - int padW = luaT_getfieldcheckint(L, 1, "padW"); - int padH = luaT_getfieldcheckint(L, 1, "padH"); - int adjW = luaT_getfieldcheckint(L, 1, "adjW"); - int adjH = luaT_getfieldcheckint(L, 1, "adjH"); - - THTensor *weight = (THTensor *)luaT_getfieldcheckudata(L, 1, "weight", torch_Tensor); - THTensor *gradColumns = (THTensor*)luaT_getfieldcheckudata(L, 1, "finput", torch_Tensor); - THTensor *gradInput = (THTensor *)luaT_getfieldcheckudata(L, 1, "gradInput", torch_Tensor); - - luaL_argcheck(L, input->nDimension == 3 || input->nDimension == 4, 2, "3D or 4D (batch mode) tensor is expected"); +void THNN_(SpatialFullConvolution_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *weight, + THTensor *gradColumns, + int kW, int kH, + int dW, int dH, + int padW, int padH, + int adjW, int adjH) +{ + int nInputPlane = THTensor_(size)(weight,0); + int nOutputPlane = THTensor_(size)(weight,1); + + THArgCheck(input->nDimension == 3 || input->nDimension == 4, 2, "3D or 4D (batch mode) tensor is expected"); int batch = 1; if (input->nDimension == 3) { @@ -239,7 +224,7 @@ static int nn_(SpatialFullConvolution_updateGradInput)(lua_State *L) { THTensor_(select)(gradOutput_n, gradOutput, 0, elt); // Extract columns: - nn_(im2col)( + THNN_(im2col)( THTensor_(data)(gradOutput_n), nOutputPlane, outputHeight, outputWidth, kH, kW, padH, padW, dH, dW, THTensor_(data)(gradColumns) @@ -275,36 +260,27 @@ static int nn_(SpatialFullConvolution_updateGradInput)(lua_State *L) { THTensor_(resize3d)(input, nInputPlane, inputHeight, inputWidth); THTensor_(resize3d)(gradInput, nInputPlane, inputHeight, inputWidth); } - - // Return gradInput - return 1; } -static int nn_(SpatialFullConvolution_accGradParameters)(lua_State *L) { - // Inputs - THTensor *input = (THTensor *)luaT_checkudata(L, 2, torch_Tensor); - THTensor *gradOutput = (THTensor *)luaT_checkudata(L, 3, torch_Tensor); - - // Params - int dW = luaT_getfieldcheckint(L, 1, "dW"); - int dH = luaT_getfieldcheckint(L, 1, "dH"); - int kW = luaT_getfieldcheckint(L, 1, "kW"); - int kH = luaT_getfieldcheckint(L, 1, "kH"); - int nInputPlane = luaT_getfieldcheckint(L, 1, "nInputPlane"); - int nOutputPlane = luaT_getfieldcheckint(L, 1, "nOutputPlane"); - int padW = luaT_getfieldcheckint(L, 1, "padW"); - int padH = luaT_getfieldcheckint(L, 1, "padH"); - int adjW = luaT_getfieldcheckint(L, 1, "adjW"); - int adjH = luaT_getfieldcheckint(L, 1, "adjH"); - float scale = luaL_optnumber(L, 4, 1); - - THTensor *gradWeight = (THTensor *)luaT_getfieldcheckudata(L, 1, "gradWeight", torch_Tensor); - THTensor *gradBias = (THTensor *)luaT_getfieldcheckudata(L, 1, "gradBias", torch_Tensor); - THTensor *columns = (THTensor*)luaT_getfieldcheckudata(L, 1, "finput", torch_Tensor); - THTensor *ones = (THTensor*)luaT_getfieldcheckudata(L, 1, "fgradInput", torch_Tensor); +void THNN_(SpatialFullConvolution_accGradParameters)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradWeight, + THTensor *gradBias, + THTensor *columns, + THTensor *ones, + int kW, int kH, + int dW, int dH, + int padW, int padH, + int adjW, int adjH, + real scale) +{ + int nInputPlane = THTensor_(size)(gradWeight,0); + int nOutputPlane = THTensor_(size)(gradWeight,1); - luaL_argcheck(L, input->nDimension == 3 || input->nDimension == 4, 2, "3D or 4D (batch mode) tensor is expected"); + THArgCheck(input->nDimension == 3 || input->nDimension == 4, 2, "3D or 4D (batch mode) tensor is expected"); int batch = 1; if (input->nDimension == 3) { @@ -344,7 +320,7 @@ static int nn_(SpatialFullConvolution_accGradParameters)(lua_State *L) { THTensor_(select)(gradOutput_n, gradOutput, 0, elt); // Extract columns: - nn_(im2col)( + THNN_(im2col)( THTensor_(data)(gradOutput_n), nOutputPlane, outputHeight, outputWidth, kH, kW, padH, padW, dH, dW, THTensor_(data)(columns) @@ -395,23 +371,6 @@ static int nn_(SpatialFullConvolution_accGradParameters)(lua_State *L) { THTensor_(resize3d)(gradOutput, nOutputPlane, outputHeight, outputWidth); THTensor_(resize3d)(input, nInputPlane, inputHeight, inputWidth); } - - // Return nothing - return 0; -} - -static const struct luaL_Reg nn_(SpatialFullConvolution__) [] = { - {"SpatialFullConvolution_updateOutput", nn_(SpatialFullConvolution_updateOutput)}, - {"SpatialFullConvolution_updateGradInput", nn_(SpatialFullConvolution_updateGradInput)}, - {"SpatialFullConvolution_accGradParameters", nn_(SpatialFullConvolution_accGradParameters)}, - {NULL, NULL} -}; - -static void nn_(SpatialFullConvolution_init)(lua_State *L) -{ - luaT_pushmetatable(L, torch_Tensor); - luaT_registeratname(L, nn_(SpatialFullConvolution__), "nn"); - lua_pop(L,1); } #endif diff --git a/lib/THNN/generic/SpatialMaxUnpooling.c b/lib/THNN/generic/SpatialMaxUnpooling.c index 045a3e6..6e7a76e 100644 --- a/lib/THNN/generic/SpatialMaxUnpooling.c +++ b/lib/THNN/generic/SpatialMaxUnpooling.c @@ -2,7 +2,7 @@ #define TH_GENERIC_FILE "generic/SpatialMaxUnpooling.c" #else -static void nn_(SpatialMaxUnpooling_updateOutput_frame)(real *input_p, real *output_p, +static void THNN_(SpatialMaxUnpooling_updateOutput_frame)(real *input_p, real *output_p, real *ind_p, long nslices, long iwidth, long iheight, @@ -31,13 +31,13 @@ static void nn_(SpatialMaxUnpooling_updateOutput_frame)(real *input_p, real *out } } -static int nn_(SpatialMaxUnpooling_updateOutput)(lua_State *L) +void THNN_(SpatialMaxUnpooling_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *indices, + int owidth, int oheight) { - THTensor *input = luaT_checkudata(L, 2, torch_Tensor); - THTensor *indices = luaT_getfieldcheckudata(L, 1, "indices", torch_Tensor); - THTensor *output = luaT_getfieldcheckudata(L, 1, "output", torch_Tensor); - int owidth = luaT_getfieldcheckint(L, 1, "owidth"); - int oheight = luaT_getfieldcheckint(L, 1, "oheight"); int dimw = 2; int dimh = 1; int nbatch = 1; @@ -49,7 +49,7 @@ static int nn_(SpatialMaxUnpooling_updateOutput)(lua_State *L) real *indices_data; - luaL_argcheck(L, input->nDimension == 3 || input->nDimension == 4 , 2, "3D or 4D (batch mode) tensor expected"); + THArgCheck(input->nDimension == 3 || input->nDimension == 4 , 2, "3D or 4D (batch mode) tensor expected"); if (!THTensor_(isSameSizeAs)(input, indices)){ THError("Invalid input size w.r.t current indices size"); } @@ -80,7 +80,7 @@ static int nn_(SpatialMaxUnpooling_updateOutput)(lua_State *L) output_data = THTensor_(data)(output); indices_data = THTensor_(data)(indices); - nn_(SpatialMaxUnpooling_updateOutput_frame)(input_data, output_data, + THNN_(SpatialMaxUnpooling_updateOutput_frame)(input_data, output_data, indices_data, nslices, iwidth, iheight, @@ -100,7 +100,7 @@ static int nn_(SpatialMaxUnpooling_updateOutput)(lua_State *L) #pragma omp parallel for private(p) for (p = 0; p < nbatch; p++) { - nn_(SpatialMaxUnpooling_updateOutput_frame)(input_data+p*nslices*iwidth*iheight, output_data+p*nslices*owidth*oheight, + THNN_(SpatialMaxUnpooling_updateOutput_frame)(input_data+p*nslices*iwidth*iheight, output_data+p*nslices*owidth*oheight, indices_data+p*nslices*iwidth*iheight, nslices, iwidth, iheight, @@ -111,11 +111,9 @@ static int nn_(SpatialMaxUnpooling_updateOutput)(lua_State *L) /* cleanup */ THTensor_(free)(input); THTensor_(free)(indices); - - return 1; } -static void nn_(SpatialMaxUnpooling_updateGradInput_frame)(real *gradInput_p, real *gradOutput_p, +static void THNN_(SpatialMaxUnpooling_updateGradInput_frame)(real *gradInput_p, real *gradOutput_p, real *ind_p, long nslices, long iwidth, long iheight, @@ -144,14 +142,14 @@ static void nn_(SpatialMaxUnpooling_updateGradInput_frame)(real *gradInput_p, re } } -static int nn_(SpatialMaxUnpooling_updateGradInput)(lua_State *L) +void THNN_(SpatialMaxUnpooling_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *indices, + int owidth, int oheight) { - THTensor *input = luaT_checkudata(L, 2, torch_Tensor); - THTensor *gradOutput = luaT_checkudata(L, 3, torch_Tensor); - THTensor *indices = luaT_getfieldcheckudata(L, 1, "indices", torch_Tensor); - THTensor *gradInput = luaT_getfieldcheckudata(L, 1, "gradInput", torch_Tensor); - int owidth = luaT_getfieldcheckint(L, 1, "owidth"); - int oheight = luaT_getfieldcheckint(L, 1, "oheight"); int dimw = 2; int dimh = 1; int nbatch = 1; @@ -197,7 +195,7 @@ static int nn_(SpatialMaxUnpooling_updateGradInput)(lua_State *L) /* backprop */ if (input->nDimension == 3) { - nn_(SpatialMaxUnpooling_updateGradInput_frame)(gradInput_data, gradOutput_data, + THNN_(SpatialMaxUnpooling_updateGradInput_frame)(gradInput_data, gradOutput_data, indices_data, nslices, iwidth, iheight, @@ -209,7 +207,7 @@ static int nn_(SpatialMaxUnpooling_updateGradInput)(lua_State *L) #pragma omp parallel for private(p) for (p = 0; p < nbatch; p++) { - nn_(SpatialMaxUnpooling_updateGradInput_frame)(gradInput_data+p*nslices*iwidth*iheight, gradOutput_data+p*nslices*owidth*oheight, + THNN_(SpatialMaxUnpooling_updateGradInput_frame)(gradInput_data+p*nslices*iwidth*iheight, gradOutput_data+p*nslices*owidth*oheight, indices_data+p*nslices*iwidth*iheight, nslices, iwidth, iheight, @@ -220,21 +218,6 @@ static int nn_(SpatialMaxUnpooling_updateGradInput)(lua_State *L) /* cleanup */ THTensor_(free)(gradOutput); THTensor_(free)(indices); - - return 1; -} - -static const struct luaL_Reg nn_(SpatialMaxUnpooling__) [] = { - {"SpatialMaxUnpooling_updateOutput", nn_(SpatialMaxUnpooling_updateOutput)}, - {"SpatialMaxUnpooling_updateGradInput", nn_(SpatialMaxUnpooling_updateGradInput)}, - {NULL, NULL} -}; - -static void nn_(SpatialMaxUnpooling_init)(lua_State *L) -{ - luaT_pushmetatable(L, torch_Tensor); - luaT_registeratname(L, nn_(SpatialMaxUnpooling__), "nn"); - lua_pop(L,1); } #endif diff --git a/lib/THNN/generic/SpatialSubSampling.c b/lib/THNN/generic/SpatialSubSampling.c index 912592c..abfbfce 100644 --- a/lib/THNN/generic/SpatialSubSampling.c +++ b/lib/THNN/generic/SpatialSubSampling.c @@ -2,19 +2,16 @@ #define TH_GENERIC_FILE "generic/SpatialSubSampling.c" #else -static int nn_(SpatialSubSampling_updateOutput)(lua_State *L) +void THNN_(SpatialSubSampling_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *weight, + THTensor *bias, + int kW, int kH, + int dW, int dH) { - THTensor *input = luaT_checkudata(L, 2, torch_Tensor); - int kW = luaT_getfieldcheckint(L, 1, "kW"); - int kH = luaT_getfieldcheckint(L, 1, "kH"); - int dW = luaT_getfieldcheckint(L, 1, "dW"); - int dH = luaT_getfieldcheckint(L, 1, "dH"); - int nInputPlane = luaT_getfieldcheckint(L, 1, "nInputPlane"); - - THTensor *weight = luaT_getfieldcheckudata(L, 1, "weight", torch_Tensor); - THTensor *bias = luaT_getfieldcheckudata(L, 1, "bias", torch_Tensor); - THTensor *output = luaT_getfieldcheckudata(L, 1, "output", torch_Tensor); - + real *weight_data = THTensor_(data)(weight); real *bias_data = THTensor_(data)(bias); real *output_data; @@ -29,9 +26,11 @@ static int nn_(SpatialSubSampling_updateOutput)(lua_State *L) long outputWidth; long outputHeight; + int nInputPlane = THTensor_(size)(weight,0); + long k; - luaL_argcheck(L, input->nDimension == 3 || input->nDimension == 4, 2, "3D or 4D(batch mode) tensor expected"); + THArgCheck(input->nDimension == 3 || input->nDimension == 4, 2, "3D or 4D(batch mode) tensor expected"); if (input->nDimension == 4) { nbatch = input->size[0]; @@ -44,8 +43,8 @@ static int nn_(SpatialSubSampling_updateOutput)(lua_State *L) outputWidth = (inputWidth - kW) / dW + 1; outputHeight = (inputHeight - kH) / dH + 1; - luaL_argcheck(L, input->size[dimh-1] == nInputPlane, 2, "invalid number of input planes"); - luaL_argcheck(L, inputWidth >= kW && inputHeight >= kH, 2, "input image smaller than kernel size"); + THArgCheck(input->size[dimh-1] == nInputPlane, 2, "invalid number of input planes"); + THArgCheck(inputWidth >= kW && inputHeight >= kH, 2, "input image smaller than kernel size"); if (input->nDimension == 3) THTensor_(resize3d)(output, nInputPlane, outputHeight, outputWidth); @@ -95,23 +94,18 @@ static int nn_(SpatialSubSampling_updateOutput)(lua_State *L) } } THTensor_(free)(input); - - return 1; } -static int nn_(SpatialSubSampling_updateGradInput)(lua_State *L) +void THNN_(SpatialSubSampling_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *weight, + int kW, int kH, + int dW, int dH) { - THTensor *input = luaT_checkudata(L, 2, torch_Tensor); - THTensor *gradOutput = luaT_checkudata(L, 3, torch_Tensor); - int kW = luaT_getfieldcheckint(L, 1, "kW"); - int kH = luaT_getfieldcheckint(L, 1, "kH"); - int dW = luaT_getfieldcheckint(L, 1, "dW"); - int dH = luaT_getfieldcheckint(L, 1, "dH"); - int nInputPlane = luaT_getfieldcheckint(L, 1, "nInputPlane"); - - THTensor *weight = luaT_getfieldcheckudata(L, 1, "weight", torch_Tensor); - THTensor *gradInput = luaT_getfieldcheckudata(L, 1, "gradInput", torch_Tensor); - + int dimw = 2; int dimh = 1; long nbatch = 1; @@ -121,6 +115,8 @@ static int nn_(SpatialSubSampling_updateGradInput)(lua_State *L) long outputWidth; long outputHeight; + int nInputPlane = THTensor_(size)(weight,0); + real *weight_data; real *gradOutput_data; real *input_data, *gradInput_data; @@ -180,24 +176,18 @@ static int nn_(SpatialSubSampling_updateGradInput)(lua_State *L) } } } - - return 1; } -static int nn_(SpatialSubSampling_accGradParameters)(lua_State *L) +void THNN_(SpatialSubSampling_accGradParameters)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradWeight, + THTensor *gradBias, + int kW, int kH, + int dW, int dH, + real scale) { - THTensor *input = luaT_checkudata(L, 2, torch_Tensor); - THTensor *gradOutput = luaT_checkudata(L, 3, torch_Tensor); - real scale = luaL_optnumber(L, 4, 1); - int kW = luaT_getfieldcheckint(L, 1, "kW"); - int kH = luaT_getfieldcheckint(L, 1, "kH"); - int dW = luaT_getfieldcheckint(L, 1, "dW"); - int dH = luaT_getfieldcheckint(L, 1, "dH"); - int nInputPlane = luaT_getfieldcheckint(L, 1, "nInputPlane"); - - THTensor *gradWeight = luaT_getfieldcheckudata(L, 1, "gradWeight", torch_Tensor); - THTensor *gradBias = luaT_getfieldcheckudata(L, 1, "gradBias", torch_Tensor); - long nbatch = 1; long dimw = 2; long dimh = 1; @@ -207,6 +197,8 @@ static int nn_(SpatialSubSampling_accGradParameters)(lua_State *L) long outputWidth; long outputHeight; + int nInputPlane = THTensor_(size)(gradWeight,0); + real *gradWeight_data; real *gradBias_data; real *gradOutput_data; @@ -270,22 +262,6 @@ static int nn_(SpatialSubSampling_accGradParameters)(lua_State *L) } THTensor_(free)(input); - - return 0; -} - -static const struct luaL_Reg nn_(SpatialSubSampling__) [] = { - {"SpatialSubSampling_updateOutput", nn_(SpatialSubSampling_updateOutput)}, - {"SpatialSubSampling_updateGradInput", nn_(SpatialSubSampling_updateGradInput)}, - {"SpatialSubSampling_accGradParameters", nn_(SpatialSubSampling_accGradParameters)}, - {NULL, NULL} -}; - -static void nn_(SpatialSubSampling_init)(lua_State *L) -{ - luaT_pushmetatable(L, torch_Tensor); - luaT_registeratname(L, nn_(SpatialSubSampling__), "nn"); - lua_pop(L,1); } #endif diff --git a/lib/THNN/generic/SpatialUpSamplingNearest.c b/lib/THNN/generic/SpatialUpSamplingNearest.c index c3cddb0..7ef093c 100644 --- a/lib/THNN/generic/SpatialUpSamplingNearest.c +++ b/lib/THNN/generic/SpatialUpSamplingNearest.c @@ -2,16 +2,16 @@ #define TH_GENERIC_FILE "generic/SpatialUpSamplingNearest.c" #else -static int nn_(SpatialUpSamplingNearest_updateOutput)(lua_State *L) +void THNN_(SpatialUpSamplingNearest_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + int scale_factor) { - // get all params - THTensor *input = luaT_checkudata(L, 2, torch_Tensor); - int scale_factor = luaT_getfieldcheckint(L, 1, "scale_factor"); int dW = scale_factor; int dH = scale_factor; int xDim = input->nDimension-2; int yDim = input->nDimension-1; - THTensor *output = luaT_getfieldcheckudata(L, 1, "output", torch_Tensor); // dims int idim = input->nDimension; // Gauranteed to be between 3 and 5 @@ -65,17 +65,15 @@ static int nn_(SpatialUpSamplingNearest_updateOutput)(lua_State *L) } } } - return 1; } -static int nn_(SpatialUpSamplingNearest_updateGradInput)(lua_State *L) +void THNN_(SpatialUpSamplingNearest_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + int scale_factor) { - // get all params - //THTensor *input = luaT_checkudata(L,2, torch_Tensor); - THTensor *gradOutput = luaT_checkudata(L,3, torch_Tensor); - THTensor *gradInput = luaT_getfieldcheckudata(L,1, "gradInput", torch_Tensor); - - int scale_factor = luaT_getfieldcheckint(L, 1, "scale_factor"); int dW = scale_factor; int dH = scale_factor; int xDim = gradInput->nDimension-2; @@ -140,20 +138,6 @@ static int nn_(SpatialUpSamplingNearest_updateGradInput)(lua_State *L) } } } - return 1; -} - -static const struct luaL_Reg nn_(SpatialUpSamplingNearest__) [] = { - {"SpatialUpSamplingNearest_updateOutput", nn_(SpatialUpSamplingNearest_updateOutput)}, - {"SpatialUpSamplingNearest_updateGradInput", nn_(SpatialUpSamplingNearest_updateGradInput)}, - {NULL, NULL} -}; - -static void nn_(SpatialUpSamplingNearest_init)(lua_State *L) -{ - luaT_pushmetatable(L, torch_Tensor); - luaT_registeratname(L, nn_(SpatialUpSamplingNearest__), "nn"); - lua_pop(L,1); } #endif diff --git a/lib/THNN/generic/THNN.h b/lib/THNN/generic/THNN.h index fca4c5c..0c0f801 100644 --- a/lib/THNN/generic/THNN.h +++ b/lib/THNN/generic/THNN.h @@ -401,6 +401,31 @@ TH_API void THNN_(Threshold_updateGradInput)( real threshold, bool inplace); +TH_API void THNN_(SpatialBatchNormalization_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *weight, + THTensor *bias, + THTensor *running_mean, + THTensor *running_var, + THTensor *save_mean, + THTensor *save_std, + bool train, + double momentum, + double eps); +TH_API void THNN_(SpatialBatchNormalization_backward)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *gradWeight, + THTensor *gradBias, + THTensor *weight, + THTensor *save_mean, + THTensor *save_std, + double scale); + TH_API void THNN_(SpatialConvolutionMM_updateOutput)( THNNState *state, THTensor *input, @@ -437,6 +462,47 @@ TH_API void THNN_(SpatialConvolutionMM_accGradParameters)( int padW, int padH, real scale); +TH_API void THNN_(SpatialConvolutionLocal_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *weight, + THTensor *bias, + THTensor *finput, + THTensor *fgradInput, + int kW, int kH, + int dW, int dH, + int padW, int padH, + long inputWidth, long inputHeight, + long outputWidth, long outputHeight); +TH_API void THNN_(SpatialConvolutionLocal_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *weight, + THTensor *finput, + THTensor *fgradInput, + int kW, int kH, + int dW, int dH, + int padW, int padH, + long inputWidth, long inputHeight, + long outputWidth, long outputHeight); +TH_API void THNN_(SpatialConvolutionLocal_accGradParameters)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradWeight, + THTensor *gradBias, + THTensor *finput, + THTensor *fgradInput, + int kW, int kH, + int dW, int dH, + int padW, int padH, + long inputWidth, long inputHeight, + long outputWidth, long outputHeight, + real scale); + TH_API void THNN_(SpatialAdaptiveMaxPooling_updateOutput)( THNNState *state, THTensor *input, @@ -470,6 +536,60 @@ TH_API void THNN_(SpatialAveragePooling_updateGradInput)( bool ceil_mode, bool count_include_pad); +TH_API void THNN_(SpatialFractionalMaxPooling_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + int outputW, int outputH, + int poolSizeW, int poolSizeH, + THTensor *indices, + THTensor *randomSamples); +TH_API void THNN_(SpatialFractionalMaxPooling_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + int outputW, int outputH, + int poolSizeW, int poolSizeH, + THTensor *indices); + +TH_API void THNN_(SpatialFullConvolution_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *weight, + THTensor *bias, + THTensor *columns, + THTensor *ones, + int kW, int kH, + int dW, int dH, + int padW, int padH, + int adjW, int adjH); +TH_API void THNN_(SpatialFullConvolution_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *weight, + THTensor *gradColumns, + int kW, int kH, + int dW, int dH, + int padW, int padH, + int adjW, int adjH); +TH_API void THNN_(SpatialFullConvolution_accGradParameters)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradWeight, + THTensor *gradBias, + THTensor *columns, + THTensor *ones, + int kW, int kH, + int dW, int dH, + int padW, int padH, + int adjW, int adjH, + real scale); + TH_API void THNN_(SpatialMaxPooling_updateOutput)( THNNState *state, THTensor *input, @@ -490,6 +610,77 @@ TH_API void THNN_(SpatialMaxPooling_updateGradInput)( int padW, int padH, bool ceil_mode); +TH_API void THNN_(SpatialMaxUnpooling_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *indices, + int owidth, int oheight); +TH_API void THNN_(SpatialMaxUnpooling_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *indices, + int owidth, int oheight); + +TH_API void THNN_(SpatialSubSampling_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + THTensor *weight, + THTensor *bias, + int kW, int kH, + int dW, int dH); +TH_API void THNN_(SpatialSubSampling_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + THTensor *weight, + int kW, int kH, + int dW, int dH); +TH_API void THNN_(SpatialSubSampling_accGradParameters)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradWeight, + THTensor *gradBias, + int kW, int kH, + int dW, int dH, + real scale); + +TH_API void THNN_(SpatialUpSamplingNearest_updateOutput)( + THNNState *state, + THTensor *input, + THTensor *output, + int scale_factor); +TH_API void THNN_(SpatialUpSamplingNearest_updateGradInput)( + THNNState *state, + THTensor *input, + THTensor *gradOutput, + THTensor *gradInput, + int scale_factor); + +TH_API void THNN_(unfolded_acc)( + THTensor *finput, + THTensor *input, + int kW, int kH, + int dW, int dH, + int padW, int padH, + int nInputPlane, + int inputWidth, int inputHeight, + int outputWidth, int outputHeight); +TH_API void THNN_(unfolded_copy)( + THTensor *finput, + THTensor *input, + int kW, int kH, + int dW, int dH, + int padW, int padH, + int nInputPlane, + int inputWidth, int inputHeight, + int outputWidth, int outputHeight); + TH_API void THNN_(VolumetricAveragePooling_updateOutput)( THNNState *state, THTensor *input, @@ -633,4 +824,5 @@ TH_API void THNN_(VolumetricMaxUnpooling_updateGradInput)( int dT, int dW, int dH, int pT, int pW, int pH); + #endif diff --git a/lib/THNN/init.c b/lib/THNN/init.c index e49ab8d..614ef26 100644 --- a/lib/THNN/init.c +++ b/lib/THNN/init.c @@ -97,21 +97,42 @@ #include "generic/TemporalMaxPooling.c" #include "THGenerateFloatTypes.h" +#include "generic/SpatialBatchNormalization.c" +#include "THGenerateFloatTypes.h" + #include "generic/unfold.c" #include "THGenerateFloatTypes.h" #include "generic/SpatialConvolutionMM.c" #include "THGenerateFloatTypes.h" +#include "generic/SpatialConvolutionLocal.c" +#include "THGenerateFloatTypes.h" + +#include "generic/SpatialFullConvolution.c" +#include "THGenerateFloatTypes.h" + #include "generic/SpatialAdaptiveMaxPooling.c" #include "THGenerateFloatTypes.h" #include "generic/SpatialAveragePooling.c" #include "THGenerateFloatTypes.h" +#include "generic/SpatialFractionalMaxPooling.c" +#include "THGenerateFloatTypes.h" + #include "generic/SpatialMaxPooling.c" #include "THGenerateFloatTypes.h" +#include "generic/SpatialMaxUnpooling.c" +#include "THGenerateFloatTypes.h" + +#include "generic/SpatialSubSampling.c" +#include "THGenerateFloatTypes.h" + +#include "generic/SpatialUpSamplingNearest.c" +#include "THGenerateFloatTypes.h" + #include "generic/VolumetricAveragePooling.c" #include "THGenerateFloatTypes.h" |