diff --git a/source/data/tensor.cpp b/source/data/tensor.cpp index 47dfeafa..5a0b3ea2 100644 --- a/source/data/tensor.cpp +++ b/source/data/tensor.cpp @@ -186,7 +186,7 @@ void Tensor::Fill(const std::vector& values, bool row_major) { const uint32_t channels = this->data_.n_slices; for (uint32_t i = 0; i < channels; ++i) { - auto& channel_data = this->data_.slice(i); + arma::fmat& channel_data = this->data_.slice(i); arma::fmat channel_data_t((float*)values.data() + i * planes, this->cols(), this->rows(), false, true); channel_data = channel_data_t.t(); diff --git a/source/layer/details/adaptive_avgpooling.cpp b/source/layer/details/adaptive_avgpooling.cpp index 421a46d1..6caa76d0 100644 --- a/source/layer/details/adaptive_avgpooling.cpp +++ b/source/layer/details/adaptive_avgpooling.cpp @@ -116,9 +116,11 @@ InferStatus AdaptiveAveragePoolingLayer::Forward( const arma::fmat& input_channel = input_data->slice(ic); arma::fmat& output_channel = output_data->slice(ic); for (uint32_t c = 0; c < input_w - pooling_w + 1; c += stride_w) { + int output_col = int(c / stride_w); for (uint32_t r = 0; r < input_h - pooling_h + 1; r += stride_h) { + int output_row = int(r / stride_h); float mean_value = 0.f; - float* output_channel_ptr = output_channel.colptr(int(c / stride_w)); + float* output_channel_ptr = output_channel.colptr(output_col); for (uint32_t w = 0; w < pooling_w; ++w) { const float* col_ptr = input_channel.colptr(c + w) + r; for (uint32_t h = 0; h < pooling_h; ++h) { @@ -126,8 +128,7 @@ InferStatus AdaptiveAveragePoolingLayer::Forward( mean_value = mean_value + current_value; } } - *(output_channel_ptr + int(r / stride_h)) = - mean_value / float(pooling_size); + *(output_channel_ptr + output_row) = mean_value / float(pooling_size); } } } diff --git a/source/layer/details/convolution.cpp b/source/layer/details/convolution.cpp index e8f70412..6f8c552b 100644 --- a/source/layer/details/convolution.cpp +++ b/source/layer/details/convolution.cpp @@ -195,26 +195,26 @@ arma::fmat ConvolutionLayer::Im2Col(sftensor input, uint32_t kernel_w, for (uint32_t ic = 0; ic < input_c_group; ++ic) { float* input_channel_ptr = input->matrix_raw_ptr(ic + group * input_c_group); - uint32_t input_channel_height = input_h; - int current_col = 0; + uint32_t current_col = 0; + uint32_t channel_row = ic * row_len; for (uint32_t w = 0; w < input_padded_w - kernel_w + 1; w += stride_w_) { for (uint32_t r = 0; r < input_padded_h - kernel_h + 1; r += stride_h_) { - float* input_matrix_c_ptr = - input_matrix.colptr(current_col) + ic * row_len; + float* input_matrix_ptr = + input_matrix.colptr(current_col) + channel_row; current_col += 1; for (uint32_t kw = 0; kw < kernel_w; ++kw) { + const uint32_t region_w = input_h * (w + kw - padding_w_); for (uint32_t kh = 0; kh < kernel_h; ++kh) { if ((kh + r >= padding_h_ && kw + w >= padding_w_) && (kh + r < input_h + padding_h_ && kw + w < input_w + padding_w_)) { - float* region_ptr = input_channel_ptr + - input_channel_height * (w + kw - padding_w_) + - r + kh - padding_h_; - *input_matrix_c_ptr = *region_ptr; + float* region_ptr = + input_channel_ptr + region_w + (r + kh - padding_h_); + *input_matrix_ptr = *region_ptr; } else { - *input_matrix_c_ptr = padding_value; // only support zero mode + *input_matrix_ptr = padding_value; // only support zero mode } - input_matrix_c_ptr += 1; + input_matrix_ptr += 1; } } } @@ -339,7 +339,7 @@ ParseParameterAttrStatus ConvolutionLayer::GetInstance( return ParseParameterAttrStatus::kParameterMissingOutChannel; } - auto out_channel = + auto out_channel = std::dynamic_pointer_cast(params.at("out_channels")); if (!out_channel) { LOG(ERROR) << "Can not find the out channel parameter"; @@ -362,7 +362,8 @@ ParseParameterAttrStatus ConvolutionLayer::GetInstance( LOG(ERROR) << "Can not find the bias parameter"; return ParseParameterAttrStatus::kParameterMissingUseBias; } - auto use_bias = std::dynamic_pointer_cast(params.at("bias")); + auto use_bias = + std::dynamic_pointer_cast(params.at("bias")); if (!use_bias) { LOG(ERROR) << "Can not find the bias parameter"; return ParseParameterAttrStatus::kParameterMissingUseBias; @@ -372,7 +373,7 @@ ParseParameterAttrStatus ConvolutionLayer::GetInstance( LOG(ERROR) << "Can not find the stride parameter"; return ParseParameterAttrStatus::kParameterMissingStride; } - auto stride = + auto stride = std::dynamic_pointer_cast(params.at("stride")); if (!stride) { LOG(ERROR) << "Can not find the stride parameter"; @@ -383,16 +384,16 @@ ParseParameterAttrStatus ConvolutionLayer::GetInstance( LOG(ERROR) << "Can not find the kernel parameter"; return ParseParameterAttrStatus::kParameterMissingKernel; } - auto kernel = - std::dynamic_pointer_cast(params.at("kernel_size")); + auto kernel = std::dynamic_pointer_cast( + params.at("kernel_size")); if (!kernel) { LOG(ERROR) << "Can not find the kernel parameter"; return ParseParameterAttrStatus::kParameterMissingKernel; } if (params.find("padding_mode") != params.end()) { - auto padding_mode = - std::dynamic_pointer_cast(params.at("padding_mode")); + auto padding_mode = std::dynamic_pointer_cast( + params.at("padding_mode")); if (padding_mode == nullptr) { LOG(ERROR) << "Can not find the padding parameter"; return ParseParameterAttrStatus::kParameterMissingPaddingMode; @@ -408,7 +409,8 @@ ParseParameterAttrStatus ConvolutionLayer::GetInstance( return ParseParameterAttrStatus::kParameterMissingPaddingMode; } - auto groups = std::dynamic_pointer_cast(params.at("groups")); + auto groups = + std::dynamic_pointer_cast(params.at("groups")); if (!groups) { LOG(ERROR) << "Can not find the groups parameter"; return ParseParameterAttrStatus::kParameterMissingGroups; diff --git a/source/layer/details/maxpooling.cpp b/source/layer/details/maxpooling.cpp index f5a1e705..4a6f6c91 100644 --- a/source/layer/details/maxpooling.cpp +++ b/source/layer/details/maxpooling.cpp @@ -133,17 +133,19 @@ InferStatus MaxPoolingLayer::Forward( const arma::fmat& input_channel = input_data->slice(ic); arma::fmat& output_channel = output_data->slice(ic); for (uint32_t c = 0; c < input_padded_w - pooling_w + 1; c += stride_w_) { + int output_col = int(c / stride_w_); for (uint32_t r = 0; r < input_padded_h - pooling_h + 1; r += stride_h_) { - float* output_channel_ptr = output_channel.colptr(int(c / stride_w_)); + int output_row = int(r / stride_h_); + float* output_channel_ptr = output_channel.colptr(output_col); float max_value = std::numeric_limits::lowest(); for (uint32_t w = 0; w < pooling_w; ++w) { + const float* col_ptr = input_channel.colptr(c + w - padding_w_); for (uint32_t h = 0; h < pooling_h; ++h) { float current_value = 0.f; if ((h + r >= padding_h_ && w + c >= padding_w_) && (h + r < input_h + padding_h_ && w + c < input_w + padding_w_)) { - const float* col_ptr = input_channel.colptr(c + w - padding_w_); current_value = *(col_ptr + r + h - padding_h_); } else { current_value = std::numeric_limits::lowest(); @@ -151,7 +153,7 @@ InferStatus MaxPoolingLayer::Forward( max_value = max_value > current_value ? max_value : current_value; } } - *(output_channel_ptr + int(r / stride_h_)) = max_value; + *(output_channel_ptr + output_row) = max_value; } } } @@ -182,7 +184,7 @@ ParseParameterAttrStatus MaxPoolingLayer::GetInstance( return ParseParameterAttrStatus::kParameterMissingPadding; } - auto padding = + auto padding = std::dynamic_pointer_cast(params.at("padding")); if (!padding) { LOG(ERROR) << "Can not find the padding parameter"; @@ -194,8 +196,8 @@ ParseParameterAttrStatus MaxPoolingLayer::GetInstance( return ParseParameterAttrStatus::kParameterMissingKernel; } - auto kernel_size = - std::dynamic_pointer_cast(params.at("kernel_size")); + auto kernel_size = std::dynamic_pointer_cast( + params.at("kernel_size")); if (!kernel_size) { LOG(ERROR) << "Can not find the kernel size parameter"; return ParseParameterAttrStatus::kParameterMissingKernel;