FM / operators

/usr/local/lib64/python3.6/site-packages/torch/include/caffe2/operators/

/usr/local/lib64/python3.6/site-packages/torch/include/caffe2/operators

Name	Size	Mode	Actions
abs_op.h	705	0644	edit dl rm
accumulate_op.h	1073	0644	edit dl rm
accuracy_op.h	652	0644	edit dl rm
acos_op.h	711	0644	edit dl rm
activation_ops_cudnn.h	4122	0644	edit dl rm
affine_channel_op.h	3450	0644	edit dl rm
alias_with_name.h	1234	0644	edit dl rm
apmeter_op.h	1027	0644	edit dl rm
arg_ops.h	2319	0644	edit dl rm
asin_op.h	711	0644	edit dl rm
assert_op.h	1335	0644	edit dl rm
async_net_barrier_op.h	904	0644	edit dl rm
atan_op.h	711	0644	edit dl rm
batch_box_cox_op.h	2287	0644	edit dl rm
batch_bucketize_op.h	720	0644	edit dl rm
batch_gather_ops.h	5264	0644	edit dl rm
batch_matmul_op.h	9602	0644	edit dl rm
batch_moments_op.h	3364	0644	edit dl rm
batch_permutation_op.h	954	0644	edit dl rm
batch_sparse_to_dense_op.h	6147	0644	edit dl rm
bbox_transform_op.h	2668	0644	edit dl rm
bisect_percentile_op.h	4921	0644	edit dl rm
boolean_mask_ops.h	2665	0644	edit dl rm
boolean_unmask_ops.h	378	0644	edit dl rm
box_with_nms_limit_op.h	4960	0644	edit dl rm
bucketize_op.h	1361	0644	edit dl rm
byte_weight_dequant_op.h	1722	0644	edit dl rm
cast_op.h	1393	0644	edit dl rm
cbrt_op.h	723	0644	edit dl rm
cc_bmm_bg_op.h	3894	0644	edit dl rm
ceil_op.h	782	0644	edit dl rm
channel_backprop_stats_op.h	737	0644	edit dl rm
channel_shuffle_op.h	1902	0644	edit dl rm
channel_stats_op.h	1807	0644	edit dl rm
clip_op.h	1639	0644	edit dl rm
collect_and_distribute_fpn_rpn_proposals_op.h	6875	0644	edit dl rm
concat_split_op.h	11850	0644	edit dl rm
conditional_op.h	487	0644	edit dl rm
conv_op.h	3125	0644	edit dl rm
conv_op_cache_cudnn.h	1935	0644	edit dl rm
conv_op_impl.h	28729	0644	edit dl rm
conv_op_shared.h	672	0644	edit dl rm
conv_pool_op_base.h	32109	0644	edit dl rm
conv_transpose_op.h	1727	0644	edit dl rm
conv_transpose_op_impl.h	18264	0644	edit dl rm
conv_transpose_op_mobile.h	1470	0644	edit dl rm
conv_transpose_op_mobile_impl.h	19587	0644	edit dl rm
conv_transpose_unpool_op_base.h	10303	0644	edit dl rm
copy_op.h	1296	0644	edit dl rm
copy_rows_to_tensor_op.h	2599	0644	edit dl rm
cosh_op.h	711	0644	edit dl rm
cosine_embedding_criterion_op.h	1127	0644	edit dl rm
cos_op.h	705	0644	edit dl rm
counter_ops.h	4596	0644	edit dl rm
create_scope_op.h	5232	0644	edit dl rm
cross_entropy_op.h	4420	0644	edit dl rm
ctc_beam_search_decoder_op.h	1102	0644	edit dl rm
ctc_greedy_decoder_op.h	817	0644	edit dl rm
cube_op.h	723	0644	edit dl rm
dataset_ops.h	5501	0644	edit dl rm
data_couple.h	464	0644	edit dl rm
deform_conv_op.h	3543	0644	edit dl rm
deform_conv_op_impl.h	13171	0644	edit dl rm
dense_vector_to_id_list_op.h	1797	0644	edit dl rm
distance_op.h	8419	0644	edit dl rm
do_op.h	6981	0644	edit dl rm
dropout_op.h	1516	0644	edit dl rm
elementwise_add_op.h	2024	0644	edit dl rm
elementwise_div_op.h	1224	0644	edit dl rm
elementwise_linear_op.h	1170	0644	edit dl rm
elementwise_logical_ops.h	5083	0644	edit dl rm
elementwise_mul_op.h	1224	0644	edit dl rm
elementwise_ops.h	19115	0644	edit dl rm
elementwise_ops_utils.h	1008	0644	edit dl rm
elementwise_op_test.h	9237	0644	edit dl rm
elementwise_sub_op.h	2025	0644	edit dl rm
elu_op.h	875	0644	edit dl rm
enforce_finite_op.h	2303	0644	edit dl rm
ensure_clipped_op.h	1608	0644	edit dl rm
ensure_cpu_output_op.h	1465	0644	edit dl rm
erf_op.h	751	0644	edit dl rm
expand_op.h	3877	0644	edit dl rm
expand_squeeze_dims_op.h	3451	0644	edit dl rm
exp_op.h	425	0644	edit dl rm
fc_inference.h	775	0644	edit dl rm
feature_maps_ops.h	32437	0644	edit dl rm
feed_blob_op.h	802	0644	edit dl rm
filler_op.h	18431	0644	edit dl rm
find_duplicate_elements_op.h	1563	0644	edit dl rm
find_op.h	2055	0644	edit dl rm
flatten_op.h	1525	0644	edit dl rm
flexible_top_k.h	936	0644	edit dl rm
floor_op.h	788	0644	edit dl rm
free_op.h	777	0644	edit dl rm
fully_connected_op.h	9351	0644	edit dl rm
fused_rowwise_8bit_conversion_ops.h	6601	0644	edit dl rm
fused_rowwise_nbitfake_conversion_ops.h	4375	0644	edit dl rm
fused_rowwise_nbit_conversion_ops.h	8723	0644	edit dl rm
fused_rowwise_random_quantization_ops.h	2607	0644	edit dl rm
gather_fused_8bit_rowwise_op.h	2179	0644	edit dl rm
gather_op.h	7505	0644	edit dl rm
gather_ranges_to_dense_op.h	8188	0644	edit dl rm
gelu_op.h	1452	0644	edit dl rm
generate_proposals_op.h	6256	0644	edit dl rm
generate_proposals_op_util_boxes.h	14309	0644	edit dl rm
generate_proposals_op_util_nms.h	26214	0644	edit dl rm
generate_proposals_op_util_nms_gpu.h	2128	0644	edit dl rm
given_tensor_byte_string_to_uint8_fill_op.h	2150	0644	edit dl rm
given_tensor_fill_op.h	3002	0644	edit dl rm
glu_op.h	1458	0644	edit dl rm
group_norm_op.h	8967	0644	edit dl rm
gru_unit_op.h	6626	0644	edit dl rm
half_float_ops.h	2732	0644	edit dl rm
hard_sigmoid_op.h	994	0644	edit dl rm
heatmap_max_keypoint_op.h	939	0644	edit dl rm
histogram_op.h	2421	0644	edit dl rm
h_softmax_op.h	4954	0644	edit dl rm
if_op.h	1764	0644	edit dl rm
im2col_op.h	8943	0644	edit dl rm
index_hash_ops.h	2232	0644	edit dl rm
index_ops.h	3155	0644	edit dl rm
inference_lstm_op.h	9881	0644	edit dl rm
instance_norm_op.h	7441	0644	edit dl rm
integral_image_op.h	923	0644	edit dl rm
is_empty_op.h	558	0644	edit dl rm
jsd_op.h	721	0644	edit dl rm
key_split_ops.h	1400	0644	edit dl rm
layer_norm_op.h	8098	0644	edit dl rm
leaky_relu_op.h	1111	0644	edit dl rm
lengths_pad_op.h	2574	0644	edit dl rm
lengths_reducer_fused_8bit_rowwise_ops.h	5532	0644	edit dl rm
lengths_reducer_fused_nbit_rowwise_ops.h	23465	0644	edit dl rm
lengths_reducer_ops.h	23315	0644	edit dl rm
lengths_reducer_rowwise_8bit_ops.h	6180	0644	edit dl rm
lengths_tile_op.h	582	0644	edit dl rm
lengths_top_k_op.h	1358	0644	edit dl rm
length_split_op.h	2259	0644	edit dl rm
listwise_l2r_op.h	1677	0644	edit dl rm
load_save_op.h	14091	0644	edit dl rm
load_save_op_util.h	1642	0644	edit dl rm
locally_connected_op.h	3872	0644	edit dl rm
locally_connected_op_impl.h	26495	0644	edit dl rm
locally_connected_op_util.h	1332	0644	edit dl rm
local_response_normalization_op.h	2804	0644	edit dl rm
log1p_op.h	717	0644	edit dl rm
logit_op.h	1129	0644	edit dl rm
log_op.h	431	0644	edit dl rm
loss_op.h	1058	0644	edit dl rm
lpnorm_op.h	1279	0644	edit dl rm
lstm_unit_op.h	6733	0644	edit dl rm
lstm_utils.h	9424	0644	edit dl rm
map_ops.h	8011	0644	edit dl rm
margin_ranking_criterion_op.h	1113	0644	edit dl rm
matmul_op.h	2843	0644	edit dl rm
max_pool_with_index_gpu.h	1155	0644	edit dl rm
mean_op.h	3252	0644	edit dl rm
merge_id_lists_op.h	2570	0644	edit dl rm
minmax_ops.h	3829	0644	edit dl rm
mish_op.h	794	0644	edit dl rm
mod_op.h	984	0644	edit dl rm
moments_op.h	4051	0644	edit dl rm
multi_class_accuracy_op.h	539	0644	edit dl rm
negate_gradient_op.h	566	0644	edit dl rm
negative_op.h	451	0644	edit dl rm
ngram_ops.h	2644	0644	edit dl rm
normalize_l1_op.h	1075	0644	edit dl rm
normalize_op.h	3013	0644	edit dl rm
no_default_engine_op.h	1063	0644	edit dl rm
numpy_tile_op.h	3643	0644	edit dl rm
one_hot_ops.h	2562	0644	edit dl rm
onnx_while_op.h	10655	0644	edit dl rm
operator_fallback_gpu.h	4155	0644	edit dl rm
op_utils_cudnn.h	2112	0644	edit dl rm
order_switch_ops.h	2149	0644	edit dl rm
pack_rnn_sequence_op.h	3074	0644	edit dl rm
pack_segments.h	2729	0644	edit dl rm
pad_op.h	2902	0644	edit dl rm
partition_ops.h	9958	0644	edit dl rm
percentile_op.h	1009	0644	edit dl rm
perplexity_op.h	447	0644	edit dl rm
piecewise_linear_transform_op.h	8281	0644	edit dl rm
pool_op.h	8525	0644	edit dl rm
pool_op_util.h	1105	0644	edit dl rm
pow_op.h	4677	0644	edit dl rm
prefetch_op.h	4661	0644	edit dl rm
prelu_op.h	1067	0644	edit dl rm
prepend_dim_op.h	2760	0644	edit dl rm
quantile_op.h	4120	0644	edit dl rm
quant_decode_op.h	5370	0644	edit dl rm
rank_loss_op.h	820	0644	edit dl rm
reciprocal_op.h	721	0644	edit dl rm
reducer_functors.h	24556	0644	edit dl rm
reduce_front_back_max_ops.h	4399	0644	edit dl rm
reduce_front_back_sum_mean_ops.h	5337	0644	edit dl rm
reduce_ops.h	9962	0644	edit dl rm
reduction_ops.h	5944	0644	edit dl rm
relu_n_op.h	990	0644	edit dl rm
relu_op.h	624	0644	edit dl rm
remove_data_blocks_op.h	2651	0644	edit dl rm
replace_nan_op.h	1170	0644	edit dl rm
reshape_op.h	5723	0644	edit dl rm
resize_3d_op.h	2677	0644	edit dl rm
resize_op.h	2307	0644	edit dl rm
reverse_packed_segs_op.h	2772	0644	edit dl rm
rmac_regions_op.h	708	0644	edit dl rm
rms_norm_op.h	2968	0644	edit dl rm
roi_align_gradient_op.h	1486	0644	edit dl rm
roi_align_op.h	2857	0644	edit dl rm
roi_align_rotated_gradient_op.h	1369	0644	edit dl rm
roi_align_rotated_op.h	1636	0644	edit dl rm
roi_pool_op.h	2503	0644	edit dl rm
rowmul_op.h	1947	0644	edit dl rm
rsqrt_op.h	729	0644	edit dl rm
scale_blobs_op.h	1458	0644	edit dl rm
scale_op.h	1019	0644	edit dl rm
segment_reduction_op.h	71022	0644	edit dl rm
self_binning_histogram_op.h	6258	0644	edit dl rm
selu_op.h	1545	0644	edit dl rm
sequence_ops.h	8264	0644	edit dl rm
shape_op.h	1638	0644	edit dl rm
sigmoid_op.h	639	0644	edit dl rm
sinh_op.h	711	0644	edit dl rm
sinusoid_position_encoding_op.h	2834	0644	edit dl rm
sin_op.h	705	0644	edit dl rm
slice_op.h	10071	0644	edit dl rm
softmax_op.h	1174	0644	edit dl rm
softmax_utils.h	447	0644	edit dl rm
softmax_with_loss_op.h	2883	0644	edit dl rm
softplus_op.h	781	0644	edit dl rm
softsign_op.h	675	0644	edit dl rm
space_batch_op.h	6848	0644	edit dl rm
sparse_dropout_with_replacement_op.h	1122	0644	edit dl rm
sparse_itemwise_dropout_with_replacement_op.h	1163	0644	edit dl rm
sparse_lp_regularizer_op.h	1130	0644	edit dl rm
sparse_normalize_op.h	834	0644	edit dl rm
sparse_to_dense_mask_op.h	10051	0644	edit dl rm
sparse_to_dense_op.h	3977	0644	edit dl rm
spatial_batch_norm_op.h	15175	0644	edit dl rm
spatial_softmax_with_loss_op.h	2182	0644	edit dl rm
sqrt_op.h	448	0644	edit dl rm
sqr_op.h	431	0644	edit dl rm
square_root_divide_op.h	1857	0644	edit dl rm
stats_put_ops.h	2813	0644	edit dl rm
stop_gradient.h	548	0644	edit dl rm
string_ops.h	2067	0644	edit dl rm
stump_func_op.h	2112	0644	edit dl rm
summarize_op.h	1875	0644	edit dl rm
swish_op.h	772	0644	edit dl rm
tanh_op.h	723	0644	edit dl rm
tan_op.h	705	0644	edit dl rm
tensor_protos_db_input.h	3633	0644	edit dl rm
text_file_reader_utils.h	2900	0644	edit dl rm
thresholded_relu_op.h	1137	0644	edit dl rm
tile_op.h	8741	0644	edit dl rm
top_k.h	1061	0644	edit dl rm
transpose_op.h	2082	0644	edit dl rm
tt_linear_op.h	6501	0644	edit dl rm
unique_ops.h	1666	0644	edit dl rm
unsafe_coalesce.h	2481	0644	edit dl rm
upsample_op.h	2246	0644	edit dl rm
utility_ops.h	49994	0644	edit dl rm
variable_length_sequence_padding.h	1378	0644	edit dl rm
weighted_multi_sampling_op.h	602	0644	edit dl rm
weighted_sample_op.h	739	0644	edit dl rm
while_op.h	1961	0644	edit dl rm
zero_gradient_op.h	347	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/torch/include/caffe2/operators/feature_maps_ops.h (32437B)

#ifndef CAFFE2_OPERATORS_FEATURE_MAPS_OPS_H_
#define CAFFE2_OPERATORS_FEATURE_MAPS_OPS_H_

#include "caffe2/core/context.h"
#include "caffe2/core/operator.h"

namespace caffe2 {

template <class Context>
class MergeDenseFeatureTensorsOp : public Operator<Context> {
 public:
  USE_OPERATOR_CONTEXT_FUNCTIONS;

template <class... Args>
  explicit MergeDenseFeatureTensorsOp(Args&&... args)
      : Operator<Context>(std::forward<Args>(args)...) {
    featureIDs_ = this->template GetRepeatedArgument<int64_t>("feature_ids");
  }
  virtual ~MergeDenseFeatureTensorsOp() noexcept {}

bool RunOnDevice() override {
    return DispatchHelper<
        TensorTypes<bool, int32_t, int64_t, float, double, std::string>>::
        call(this, Input(0));
  }

template <typename T>
  bool DoRunWithType() {
    auto& dense_data = Input(0);
    int numExamples = dense_data.size(0);
    int numFeatures = dense_data.size(1);

const bool* inPresenceData = Input(1).template data<bool>();
    int totalNumFeatures = 0;
    for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
      for (int inputIndex = 0; inputIndex < numFeatures; ++inputIndex) {
        if (inPresenceData[exampleIndex * numFeatures + inputIndex]) {
          ++totalNumFeatures;
        }
      }
    }

auto* outLengths = Output(0, {numExamples}, at::dtype<int32_t>());
    auto* outKeys = Output(1, {totalNumFeatures}, at::dtype<int64_t>());
    auto* outValues = Output(2, {totalNumFeatures}, at::dtype<T>());

int32_t* outLengthsData = outLengths->template mutable_data<int32_t>();
    int64_t* outKeysData = outKeys->template mutable_data<int64_t>();
    T* outValuesData = outValues->template mutable_data<T>();
    const T* inData =
      Input(0).template data<T>();

int keysOffset = 0;
    for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
      outLengthsData[exampleIndex] = 0;
      auto offset = exampleIndex * numFeatures;
      for (int inputIndex = 0; inputIndex < numFeatures; ++inputIndex) {
        if (inPresenceData[offset]) {
          ++outLengthsData[exampleIndex];
          outKeysData[keysOffset] = featureIDs_[inputIndex];
          outValuesData[keysOffset] = inData[offset];
          ++keysOffset;
        }
        offset++;
      }
    }
    return true;
  }

private:
  std::vector<int64_t> featureIDs_;
};

template <class Context>
class MergeSingleScalarFeatureTensorsOp : public Operator<Context> {
 public:
  USE_OPERATOR_CONTEXT_FUNCTIONS;

template <class... Args>
  explicit MergeSingleScalarFeatureTensorsOp(Args&&... args)
      : Operator<Context>(std::forward<Args>(args)...) {
    numInputs_ = InputSize() / kNumTensorsPerInput;
    featureIDs_ = this->template GetRepeatedArgument<int64_t>("feature_ids");
  }
  virtual ~MergeSingleScalarFeatureTensorsOp() noexcept {}

bool RunOnDevice() override {
    return DispatchHelper<
        TensorTypes<bool, int32_t, int64_t, float, double, std::string>>::
        call(this, Input(0));
  }

template <typename T>
  bool DoRunWithType() {
    int numExamples = Input(0).numel();
    int totalNumFeatures = 0;
    for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
      const bool* inPresenceData =
          Input(kNumTensorsPerInput * inputIndex + 1).template data<bool>();
      for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
        if (inPresenceData[exampleIndex]) {
          ++totalNumFeatures;
        }
      }
    }

int keysOffset = 0;
    for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
      outLengthsData[exampleIndex] = 0;
      for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
        const T* inData =
            Input(kNumTensorsPerInput * inputIndex).template data<T>();
        const bool* inPresenceData =
            Input(kNumTensorsPerInput * inputIndex + 1).template data<bool>();
        if (inPresenceData[exampleIndex]) {
          ++outLengthsData[exampleIndex];
          outKeysData[keysOffset] = featureIDs_[inputIndex];
          outValuesData[keysOffset] = inData[exampleIndex];
          ++keysOffset;
        }
      }
    }
    return true;
  }

private:
  const int kNumTensorsPerInput = 2;
  int numInputs_;
  std::vector<int64_t> featureIDs_;
};

template <class Context>
class MergeSingleScalarFeatureTensorsGradientOp : public Operator<Context> {
 public:
  USE_OPERATOR_CONTEXT_FUNCTIONS;

template <class... Args>
  explicit MergeSingleScalarFeatureTensorsGradientOp(Args&&... args)
      : Operator<Context>(std::forward<Args>(args)...) {
    numFeatureInputs_ = InputSize() - 1; // Everything other than values_grad
  }
  virtual ~MergeSingleScalarFeatureTensorsGradientOp() noexcept {}

bool RunOnDevice() override {
    return DispatchHelper<
        TensorTypes<bool, int32_t, int64_t, float, double, std::string>>::
        call(this, Input(InputSize() - 1));
  }

template <typename T>
  bool DoRunWithType() {
    int numExamples = Input(0).numel();
    for (int inputIndex = 0; inputIndex < numFeatureInputs_; ++inputIndex) {
      Output(inputIndex)->ResizeLike(Input(inputIndex));
    }

const T* inValuesGradData = Input(InputSize() - 1).template data<T>();

T default_value = T();
    int valuesOffset = 0;
    for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
      for (int inputIndex = 0; inputIndex < numFeatureInputs_; ++inputIndex) {
        const bool* inPresenceData = Input(inputIndex).template data<bool>();
        T* outFeatureData = Output(inputIndex)->template mutable_data<T>();
        if (inPresenceData[exampleIndex]) {
          outFeatureData[exampleIndex] = inValuesGradData[valuesOffset];
          ++valuesOffset;
        } else {
          outFeatureData[exampleIndex] = default_value;
        }
      }
    }
    return true;
  }

private:
  int numFeatureInputs_;
};

template <class Context>
class MergeSingleListFeatureTensorsOp : public Operator<Context> {
 public:
  USE_OPERATOR_CONTEXT_FUNCTIONS;

template <class... Args>
  explicit MergeSingleListFeatureTensorsOp(Args&&... args)
      : Operator<Context>(std::forward<Args>(args)...) {
    numInputs_ = InputSize() / kNumTensorsPerInput;
    inValuesOffset_.resize(numInputs_);
    featureIDs_ = this->template GetRepeatedArgument<int64_t>("feature_ids");
  }
  virtual ~MergeSingleListFeatureTensorsOp() noexcept {}

bool RunOnDevice() override {
    return DispatchHelper<
        TensorTypes<bool, int32_t, int64_t, float, double, std::string>>::
        call(this, Input(1));
  }

template <typename T>
  bool DoRunWithType() {
    int numExamples = Input(0).numel();
    int totalNumFeatures = 0;
    int totalNumValues = 0;
    for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
      const int32_t* inLengthsData =
          Input(kNumTensorsPerInput * inputIndex).template data<int32_t>();
      const bool* inPresenceData =
          Input(kNumTensorsPerInput * inputIndex + 2).template data<bool>();
      for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
        if (inPresenceData[exampleIndex]) {
          ++totalNumFeatures;
          totalNumValues += inLengthsData[exampleIndex];
        }
      }
    }

auto* outLengths = Output(0, {numExamples}, at::dtype<int32_t>());
    auto* outKeys = Output(1, {totalNumFeatures}, at::dtype<int64_t>());
    auto* outValuesLengths =
        Output(2, {totalNumFeatures}, at::dtype<int32_t>());
    auto* outValuesValues = Output(3, {totalNumValues}, at::dtype<T>());

int32_t* outLengthsData = outLengths->template mutable_data<int32_t>();
    int64_t* outKeysData = outKeys->template mutable_data<int64_t>();
    int32_t* outValuesLengthsData =
        outValuesLengths->template mutable_data<int32_t>();
    T* outValuesValuesData = outValuesValues->template mutable_data<T>();

int keysOffset = 0;
    int valuesOffset = 0;
    for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
      inValuesOffset_[inputIndex] = 0;
    }
    for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
      outLengthsData[exampleIndex] = 0;
      for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
        const int32_t* inLengthsData =
            Input(kNumTensorsPerInput * inputIndex).template data<int32_t>();
        const auto& inValues = Input(kNumTensorsPerInput * inputIndex + 1);
        const bool* inPresenceData =
            Input(kNumTensorsPerInput * inputIndex + 2).template data<bool>();
        if (inPresenceData[exampleIndex]) {
          ++outLengthsData[exampleIndex];
          outKeysData[keysOffset] = featureIDs_[inputIndex];
          outValuesLengthsData[keysOffset] = inLengthsData[exampleIndex];
          context_.CopyItemsSameDevice(
              inValues.dtype(),
              inLengthsData[exampleIndex],
              &inValues.template data<T>()[inValuesOffset_[inputIndex]],
              &outValuesValuesData[valuesOffset]);
          valuesOffset += inLengthsData[exampleIndex];
          inValuesOffset_[inputIndex] += inLengthsData[exampleIndex];
          ++keysOffset;
        }
      }
    }
    return true;
  }

private:
  const int kNumTensorsPerInput = 3;
  int numInputs_;
  std::vector<int> inValuesOffset_;
  std::vector<int64_t> featureIDs_;
};

template <class Context>
class MergeSingleListOrMapFeatureTensorsGradientOp : public Operator<Context> {
 public:
  USE_OPERATOR_CONTEXT_FUNCTIONS;

template <class... Args>
  explicit MergeSingleListOrMapFeatureTensorsGradientOp(Args&&... args)
      : Operator<Context>(std::forward<Args>(args)...) {
    numFeatureInputs_ = (InputSize() - 1) / kNumTensorsPerInput;
  }
  virtual ~MergeSingleListOrMapFeatureTensorsGradientOp() noexcept {}

bool RunOnDevice() override {
    return DispatchHelper<
        TensorTypes<bool, int32_t, int64_t, float, double, std::string>>::
        call(this, Input(InputSize() - 1));
  }

template <typename T>
  bool DoRunWithType() {
    int numExamples = Input(0).numel();
    std::vector<int> outValuesOffset(numFeatureInputs_);
    for (int inputIndex = 0; inputIndex < numFeatureInputs_; ++inputIndex) {
      int inputNumValues = 0;
      const int32_t* inLengthsData =
          Input(kNumTensorsPerInput * inputIndex).template data<int32_t>();
      const bool* inPresenceData =
          Input(kNumTensorsPerInput * inputIndex + 1).template data<bool>();
      for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
        if (inPresenceData[exampleIndex]) {
          inputNumValues += inLengthsData[exampleIndex];
        }
      }
      Output(inputIndex)->Resize(inputNumValues);
    }

const auto& inValuesValuesGrad = Input(InputSize() - 1);
    const T* inValuesValuesGradData = inValuesValuesGrad.template data<T>();

int inValuesValuesOffset = 0;
    for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
      for (int inputIndex = 0; inputIndex < numFeatureInputs_; ++inputIndex) {
        const int32_t* inLengthsData =
            Input(kNumTensorsPerInput * inputIndex).template data<int32_t>();
        const bool* inPresenceData =
            Input(kNumTensorsPerInput * inputIndex + 1).template data<bool>();
        if (inPresenceData[exampleIndex]) {
          T* outFeatureValues = Output(inputIndex)->template mutable_data<T>();
          context_.CopyItemsSameDevice(
              inValuesValuesGrad.dtype(),
              inLengthsData[exampleIndex],
              &inValuesValuesGradData[inValuesValuesOffset],
              &outFeatureValues[outValuesOffset[inputIndex]]);
          outValuesOffset[inputIndex] += inLengthsData[exampleIndex];
          inValuesValuesOffset += inLengthsData[exampleIndex];
        }
      }
    }
    return true;
  }

private:
  const int kNumTensorsPerInput = 2;
  int numFeatureInputs_;
};

template <class Context>
class MergeSingleMapFeatureTensorsOp : public Operator<Context> {
 public:
  USE_OPERATOR_CONTEXT_FUNCTIONS;

template <class... Args>
  explicit MergeSingleMapFeatureTensorsOp(Args&&... args)
      : Operator<Context>(std::forward<Args>(args)...) {
    numInputs_ = InputSize() / kNumTensorsPerInput;
    inValuesOffset_.resize(numInputs_);
    featureIDs_ = this->template GetRepeatedArgument<int64_t>("feature_ids");
  }
  virtual ~MergeSingleMapFeatureTensorsOp() noexcept {}

bool RunOnDevice() override {
    return DispatchHelper<
        TensorTypes<bool, int32_t, int64_t, float, double, std::string>>::
        call(this, Input(1));
  }

template <typename K>
  bool DoRunWithType() {
    return DispatchHelper<
        TensorTypes2<bool, int32_t, int64_t, float, double, std::string>,
        K>::call(this, Input(2));
  }

template <typename K, typename V>
  bool DoRunWithType2() {
    int numExamples = Input(0).numel();
    int totalNumFeatures = 0;
    int totalNumValues = 0;
    for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
      const int32_t* inLengthsData =
          Input(kNumTensorsPerInput * inputIndex).template data<int32_t>();
      const bool* inPresenceData =
          Input(kNumTensorsPerInput * inputIndex + 3).template data<bool>();
      for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
        if (inPresenceData[exampleIndex]) {
          ++totalNumFeatures;
          totalNumValues += inLengthsData[exampleIndex];
        }
      }
    }

auto* outLengths = Output(0, {numExamples}, at::dtype<int32_t>());
    auto* outKeys = Output(1, {totalNumFeatures}, at::dtype<int64_t>());
    auto* outValuesLengths =
        Output(2, {totalNumFeatures}, at::dtype<int32_t>());
    auto* outValuesKeys = Output(3, {totalNumValues}, at::dtype<K>());
    auto* outValuesValues = Output(4, {totalNumValues}, at::dtype<V>());

int32_t* outLengthsData = outLengths->template mutable_data<int32_t>();
    int64_t* outKeysData = outKeys->template mutable_data<int64_t>();
    int32_t* outValuesLengthsData =
        outValuesLengths->template mutable_data<int32_t>();
    K* outValuesKeysData = outValuesKeys->template mutable_data<K>();
    V* outValuesValuesData = outValuesValues->template mutable_data<V>();

int keysOffset = 0;
    int valuesOffset = 0;
    for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
      inValuesOffset_[inputIndex] = 0;
    }
    for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
      outLengthsData[exampleIndex] = 0;
      for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
        const int32_t* inLengthsData =
            Input(kNumTensorsPerInput * inputIndex).template data<int32_t>();
        const auto& inKeys = Input(kNumTensorsPerInput * inputIndex + 1);
        const auto& inValues = Input(kNumTensorsPerInput * inputIndex + 2);
        const bool* inPresenceData =
            Input(kNumTensorsPerInput * inputIndex + 3).template data<bool>();
        if (inPresenceData[exampleIndex]) {
          ++outLengthsData[exampleIndex];
          outKeysData[keysOffset] = featureIDs_[inputIndex];
          outValuesLengthsData[keysOffset] = inLengthsData[exampleIndex];
          context_.CopyItemsSameDevice(
              inKeys.dtype(),
              inLengthsData[exampleIndex],
              &inKeys.template data<K>()[inValuesOffset_[inputIndex]],
              &outValuesKeysData[valuesOffset]);
          context_.CopyItemsSameDevice(
              inValues.dtype(),
              inLengthsData[exampleIndex],
              &inValues.template data<V>()[inValuesOffset_[inputIndex]],
              &outValuesValuesData[valuesOffset]);
          valuesOffset += inLengthsData[exampleIndex];
          inValuesOffset_[inputIndex] += inLengthsData[exampleIndex];
          ++keysOffset;
        }
      }
    }
    return true;
  }

private:
  const int kNumTensorsPerInput = 4;
  int numInputs_;
  std::vector<int> inValuesOffset_;
  std::vector<int64_t> featureIDs_;
};

template <class Context>
class MergeMultiScalarFeatureTensorsOp : public Operator<Context> {
 public:
  USE_OPERATOR_CONTEXT_FUNCTIONS;

template <class... Args>
  explicit MergeMultiScalarFeatureTensorsOp(Args&&... args)
      : Operator<Context>(std::forward<Args>(args)...) {
    numInputs_ = InputSize() / kNumTensorsPerInput;
    inKeysOffset_.resize(numInputs_);
  }
  virtual ~MergeMultiScalarFeatureTensorsOp() noexcept {}

bool RunOnDevice() override {
    return DispatchHelper<
        TensorTypes<bool, int32_t, int64_t, float, double, std::string>>::
        call(this, Input(2));
  }

template <typename T>
  bool DoRunWithType() {
    int numExamples = Input(0).numel();
    int totalNumFeatures = 0;
    for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
      totalNumFeatures += Input(kNumTensorsPerInput * inputIndex + 1).numel();
    }

int outKeysOffset = 0;
    for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
      inKeysOffset_[inputIndex] = 0;
    }
    for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
      outLengthsData[exampleIndex] = 0;
      for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
        const int32_t* inLengthsData =
            Input(kNumTensorsPerInput * inputIndex).template data<int32_t>();
        auto inputKeysBlobIdx = kNumTensorsPerInput * inputIndex + 1;
        const int64_t* inKeysData =
            Input(inputKeysBlobIdx).template data<int64_t>();
        const T* inValuesData =
            Input(kNumTensorsPerInput * inputIndex + 2).template data<T>();
        outLengthsData[exampleIndex] += inLengthsData[exampleIndex];
        for (int featureIndex = 0; featureIndex < inLengthsData[exampleIndex];
             ++featureIndex) {
          CAFFE_ENFORCE_LT(outKeysOffset, totalNumFeatures);
          CAFFE_ENFORCE_LT(
              inKeysOffset_[inputIndex], Input(inputKeysBlobIdx).numel());
          outKeysData[outKeysOffset] = inKeysData[inKeysOffset_[inputIndex]];
          outValuesData[outKeysOffset] =
              inValuesData[inKeysOffset_[inputIndex]];
          ++outKeysOffset;
          ++inKeysOffset_[inputIndex];
        }
      }
    }

return true;
  }

private:
  const int kNumTensorsPerInput = 3;
  int numInputs_;
  std::vector<int> inKeysOffset_;
};

template <class Context>
class MergeMultiScalarFeatureTensorsGradientOp : public Operator<Context> {
 public:
  USE_OPERATOR_CONTEXT_FUNCTIONS;

template <class... Args>
  explicit MergeMultiScalarFeatureTensorsGradientOp(Args&&... args)
      : Operator<Context>(std::forward<Args>(args)...) {
    numFeatureInputs_ = (InputSize() - 1) / kNumTensorsPerInput;
  }
  virtual ~MergeMultiScalarFeatureTensorsGradientOp() noexcept {}

bool RunOnDevice() override {
    return DispatchHelper<
        TensorTypes<bool, int32_t, int64_t, float, double, std::string>>::
        call(this, Input(InputSize() - 1));
  }

template <typename T>
  bool DoRunWithType() {
    int numExamples = Input(0).numel();
    std::vector<int> outValuesOffset(numFeatureInputs_);
    for (int inputIndex = 0; inputIndex < numFeatureInputs_; ++inputIndex) {
      int inputNumValues = 0;
      const int32_t* inLengthsData =
          Input(kNumTensorsPerInput * inputIndex).template data<int32_t>();
      for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
        inputNumValues += inLengthsData[exampleIndex];
      }
      Output(inputIndex)->Resize(inputNumValues);
    }

const auto& inValuesGrad = Input(InputSize() - 1);
    const T* inValuesGradData = inValuesGrad.template data<T>();

int inValuesOffset = 0;
    for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
      for (int inputIndex = 0; inputIndex < numFeatureInputs_; ++inputIndex) {
        const int32_t* inLengthsData =
            Input(kNumTensorsPerInput * inputIndex).template data<int32_t>();
        if (inLengthsData[exampleIndex] > 0) {
          T* outFeatureValues = Output(inputIndex)->template mutable_data<T>();
          context_.CopyItemsSameDevice(
              inValuesGrad.dtype(),
              inLengthsData[exampleIndex],
              &inValuesGradData[inValuesOffset],
              &outFeatureValues[outValuesOffset[inputIndex]]);
          outValuesOffset[inputIndex] += inLengthsData[exampleIndex];
          inValuesOffset += inLengthsData[exampleIndex];
        }
      }
    }
    return true;
  }

private:
  int kNumTensorsPerInput = 1;
  int numFeatureInputs_;
};

template <class Context>
class MergeMultiListFeatureTensorsOp : public Operator<Context> {
 public:
  USE_OPERATOR_CONTEXT_FUNCTIONS;

template <class... Args>
  explicit MergeMultiListFeatureTensorsOp(Args&&... args)
      : Operator<Context>(std::forward<Args>(args)...) {
    numInputs_ = InputSize() / kNumTensorsPerInput;
    inKeysOffset_.resize(numInputs_);
    inValuesValuesOffset_.resize(numInputs_);
  }
  virtual ~MergeMultiListFeatureTensorsOp() noexcept {}

bool RunOnDevice() override {
    return DispatchHelper<
        TensorTypes<bool, int32_t, int64_t, float, double, std::string>>::
        call(this, Input(3));
  }

template <typename T>
  bool DoRunWithType() {
    int numExamples = Input(0).numel();
    int totalNumFeatures = 0;
    int totalNumValues = 0;
    for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
      totalNumFeatures += Input(kNumTensorsPerInput * inputIndex + 1).numel();
      totalNumValues += Input(kNumTensorsPerInput * inputIndex + 3).numel();
    }

int outKeysOffset = 0;
    int outValuesValuesOffset = 0;
    for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
      inKeysOffset_[inputIndex] = 0;
      inValuesValuesOffset_[inputIndex] = 0;
    }
    for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
      outLengthsData[exampleIndex] = 0;
      for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
        const int32_t* inLengthsData =
            Input(kNumTensorsPerInput * inputIndex).template data<int32_t>();
        const int64_t* inKeysData = Input(kNumTensorsPerInput * inputIndex + 1)
                                        .template data<int64_t>();
        const int32_t* inValuesLengthsData =
            Input(kNumTensorsPerInput * inputIndex + 2)
                .template data<int32_t>();
        const auto& inValuesValues =
            Input(kNumTensorsPerInput * inputIndex + 3);
        outLengthsData[exampleIndex] += inLengthsData[exampleIndex];
        for (int featureIndex = 0; featureIndex < inLengthsData[exampleIndex];
             ++featureIndex) {
          outKeysData[outKeysOffset] = inKeysData[inKeysOffset_[inputIndex]];
          outValuesLengthsData[outKeysOffset] =
              inValuesLengthsData[inKeysOffset_[inputIndex]];
          context_.CopyItemsSameDevice(
              inValuesValues.dtype(),
              inValuesLengthsData[inKeysOffset_[inputIndex]],
              &inValuesValues
                   .template data<T>()[inValuesValuesOffset_[inputIndex]],
              &outValuesValuesData[outValuesValuesOffset]);
          outValuesValuesOffset +=
              inValuesLengthsData[inKeysOffset_[inputIndex]];
          inValuesValuesOffset_[inputIndex] +=
              inValuesLengthsData[inKeysOffset_[inputIndex]];
          ++outKeysOffset;
          ++inKeysOffset_[inputIndex];
        }
      }
    }

return true;
  }

private:
  const int kNumTensorsPerInput = 4;
  int numInputs_;
  std::vector<int> inKeysOffset_;
  std::vector<int> inValuesValuesOffset_;
};

template <class Context>
class MergeMultiMapFeatureTensorsOp : public Operator<Context> {
 public:
  USE_OPERATOR_CONTEXT_FUNCTIONS;

template <class... Args>
  explicit MergeMultiMapFeatureTensorsOp(Args&&... args)
      : Operator<Context>(std::forward<Args>(args)...) {
    numInputs_ = InputSize() / kNumTensorsPerInput;
    inKeysOffset_.resize(numInputs_);
    inValuesValuesOffset_.resize(numInputs_);
  }
  virtual ~MergeMultiMapFeatureTensorsOp() noexcept {}

bool RunOnDevice() override {
    return DispatchHelper<
        TensorTypes<bool, int32_t, int64_t, float, double, std::string>>::
        call(this, Input(3));
  }

template <typename K>
  bool DoRunWithType() {
    return DispatchHelper<
        TensorTypes2<bool, int32_t, int64_t, float, double, std::string>,
        K>::call(this, Input(4));
  }

auto* outLengths = Output(0, {numExamples}, at::dtype<int32_t>());
    auto* outKeys = Output(1, {totalNumFeatures}, at::dtype<int64_t>());
    auto* outValuesLengths =
        Output(2, {totalNumFeatures}, at::dtype<int32_t>());
    auto* outValuesKeys = Output(3, {totalNumValues}, at::dtype<K>());
    auto* outValuesValues = Output(4, {totalNumValues}, at::dtype<V>());

int32_t* outLengthsData = outLengths->template mutable_data<int32_t>();
    int64_t* outKeysData = outKeys->template mutable_data<int64_t>();
    int32_t* outValuesLengthsData =
        outValuesLengths->template mutable_data<int32_t>();
    K* outValuesKeysData = outValuesKeys->template mutable_data<K>();
    V* outValuesValuesData = outValuesValues->template mutable_data<V>();

int outKeysOffset = 0;
    int outValuesValuesOffset = 0;
    for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
      inKeysOffset_[inputIndex] = 0;
      inValuesValuesOffset_[inputIndex] = 0;
    }
    for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
      outLengthsData[exampleIndex] = 0;
      for (int inputIndex = 0; inputIndex < numInputs_; ++inputIndex) {
        const int32_t* inLengthsData =
            Input(kNumTensorsPerInput * inputIndex).template data<int32_t>();
        const int64_t* inKeysData = Input(kNumTensorsPerInput * inputIndex + 1)
                                        .template data<int64_t>();
        const int32_t* inValuesLengthsData =
            Input(kNumTensorsPerInput * inputIndex + 2)
                .template data<int32_t>();
        const auto& inValuesKeys = Input(kNumTensorsPerInput * inputIndex + 3);
        const auto& inValuesValues =
            Input(kNumTensorsPerInput * inputIndex + 4);
        outLengthsData[exampleIndex] += inLengthsData[exampleIndex];
        for (int featureIndex = 0; featureIndex < inLengthsData[exampleIndex];
             ++featureIndex) {
          outKeysData[outKeysOffset] = inKeysData[inKeysOffset_[inputIndex]];
          outValuesLengthsData[outKeysOffset] =
              inValuesLengthsData[inKeysOffset_[inputIndex]];
          context_.CopyItemsSameDevice(
              inValuesKeys.dtype(),
              inValuesLengthsData[inKeysOffset_[inputIndex]],
              &inValuesKeys
                   .template data<K>()[inValuesValuesOffset_[inputIndex]],
              &outValuesKeysData[outValuesValuesOffset]);
          context_.CopyItemsSameDevice(
              inValuesValues.dtype(),
              inValuesLengthsData[inKeysOffset_[inputIndex]],
              &inValuesValues
                   .template data<V>()[inValuesValuesOffset_[inputIndex]],
              &outValuesValuesData[outValuesValuesOffset]);
          outValuesValuesOffset +=
              inValuesLengthsData[inKeysOffset_[inputIndex]];
          inValuesValuesOffset_[inputIndex] +=
              inValuesLengthsData[inKeysOffset_[inputIndex]];
          ++outKeysOffset;
          ++inKeysOffset_[inputIndex];
        }
      }
    }

return true;
  }

private:
  const int kNumTensorsPerInput = 5;
  int numInputs_;
  std::vector<int> inKeysOffset_;
  std::vector<int> inValuesValuesOffset_;
};

template <class Context>
class MergeMultiListOrMapFeatureTensorsGradientOp : public Operator<Context> {
 public:
  USE_OPERATOR_CONTEXT_FUNCTIONS;

template <class... Args>
  explicit MergeMultiListOrMapFeatureTensorsGradientOp(Args&&... args)
      : Operator<Context>(std::forward<Args>(args)...) {
    numFeatureInputs_ = (InputSize() - 1) / kNumTensorsPerInput;
  }
  virtual ~MergeMultiListOrMapFeatureTensorsGradientOp() noexcept {}

bool RunOnDevice() override {
    return DispatchHelper<
        TensorTypes<bool, int32_t, int64_t, float, double, std::string>>::
        call(this, Input(InputSize() - 1));
  }

template <typename T>
  bool DoRunWithType() {
    int numExamples = Input(0).numel();
    std::vector<int> outValuesLengthOffset(numFeatureInputs_);
    std::vector<int> outValuesValuesOffset(numFeatureInputs_);
    for (int inputIndex = 0; inputIndex < numFeatureInputs_; ++inputIndex) {
      int inputNumValues = 0;
      auto& inValuesLength = Input(kNumTensorsPerInput * inputIndex + 1);
      const int32_t* inValuesLengthsData =
          inValuesLength.template data<int32_t>();
      for (int valuesIndex = 0; valuesIndex < inValuesLength.numel();
           ++valuesIndex) {
        inputNumValues += inValuesLengthsData[valuesIndex];
      }
      Output(inputIndex)->Resize(inputNumValues);
    }

const auto& inValuesValuesGrad = Input(InputSize() - 1);
    const T* inValuesValuesGradData = inValuesValuesGrad.template data<T>();

int inValuesValuesOffset = 0;
    for (int exampleIndex = 0; exampleIndex < numExamples; ++exampleIndex) {
      for (int inputIndex = 0; inputIndex < numFeatureInputs_; ++inputIndex) {
        const int32_t* inLengthsData =
            Input(kNumTensorsPerInput * inputIndex).template data<int32_t>();
        const int32_t* inValuesLengthsData =
            Input(kNumTensorsPerInput * inputIndex + 1)
                .template data<int32_t>();
        int valuesLengthCopy = 0;
        for (int valuesLengthIndex = 0;
             valuesLengthIndex < inLengthsData[exampleIndex];
             ++valuesLengthIndex) {
          valuesLengthCopy += inValuesLengthsData
              [outValuesLengthOffset[inputIndex] + valuesLengthIndex];
        }
        if (valuesLengthCopy > 0) {
          T* outFeatureValues = Output(inputIndex)->template mutable_data<T>();
          context_.CopyItemsSameDevice(
              inValuesValuesGrad.dtype(),
              valuesLengthCopy,
              &inValuesValuesGradData[inValuesValuesOffset],
              &outFeatureValues[outValuesValuesOffset[inputIndex]]);
        }
        outValuesLengthOffset[inputIndex] += inLengthsData[exampleIndex];
        outValuesValuesOffset[inputIndex] += valuesLengthCopy;
        inValuesValuesOffset += valuesLengthCopy;
      }
    }
    return true;
  }

private:
  int kNumTensorsPerInput = 2;
  int numFeatureInputs_;
};

} // namespace caffe2

#endif // CAFFE2_OPERATORS_FEATURE_MAPS_OPS_H_

cmd: