unary.h 13.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/* Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. */

#pragma once

// See Note [ Why still include the fluid headers? ]
18 19 20
#include "paddle/phi/common/scalar.h"
#include "paddle/phi/common/scalar_array.h"
#include "paddle/phi/core/meta_tensor.h"
21

22
namespace phi {
23

24 25
class MetaConfig;

26
// Common InferMeta Functions for unary operators, The format like:
27
//
28 29
//   void [FunctionDesc|OpName]InferMeta(const MetaTensor& x, ..., MetaTensor*
//   out) {}
30 31 32 33
//
// NOTE: The name "InferShape" may be not appropriate. "InferMeta" may be good.
// Because functions in this file not only can infer shape, but also need
// infer lod or other useful data.
34 35
//
// The InferMeta Functions in this file are arranged in alphabetic order.
36

Z
zyfncg 已提交
37 38 39 40 41 42 43 44
void ArgMinMaxInferMeta(const MetaTensor& x,
                        int64_t axis,
                        bool keepdims,
                        bool flatten,
                        int dtype,
                        MetaTensor* out,
                        MetaConfig config = MetaConfig());

L
Linjie Chen 已提交
45 46 47 48 49 50
void ArgsortInferMeta(const MetaTensor& input,
                      int axis,
                      bool descending,
                      MetaTensor* output,
                      MetaTensor* indices);

51 52 53 54 55 56
void BatchSizeLikeInferMeta(const MetaTensor& x,
                            const std::vector<int>& shape,
                            int x_batch_size_dim,
                            int out_batch_size_dim,
                            MetaTensor* out);

57
void CastInferMeta(const MetaTensor& x, DataType out_dtype, MetaTensor* out);
58

59 60
void CholeskyInferMeta(const MetaTensor& x, bool upper, MetaTensor* out);

61 62 63 64 65
void CopyToInferMeta(const MetaTensor& x,
                     Backend backend,
                     bool blocking,
                     MetaTensor* out);

66
void CreateLikeInferMeta(const MetaTensor& x, DataType dtype, MetaTensor* out);
67

68 69 70 71 72 73 74
void CumsumInferMeta(const MetaTensor& x,
                     int axis,
                     bool flatten,
                     bool exclusive,
                     bool reverse,
                     MetaTensor* out);

Z
zyfncg 已提交
75 76 77 78 79 80 81 82
void DiagInferMeta(const MetaTensor& x,
                   int offset,
                   float padding_value,
                   MetaTensor* out);

void DiagonalInferMeta(
    const MetaTensor& input, int offset, int axis1, int axis2, MetaTensor* out);

H
hong 已提交
83 84
void DropoutInferMeta(const MetaTensor& x, MetaTensor* out, MetaTensor* mask);

Z
zyfncg 已提交
85 86 87 88 89 90 91 92 93 94
void EighInferMeta(const MetaTensor& x,
                   const std::string& uplo,
                   MetaTensor* out_w,
                   MetaTensor* out_v);

void FlattenInferMeta(const MetaTensor& x,
                      int start_axis,
                      int stop_axis,
                      MetaTensor* out);

95 96 97 98 99 100
void FlattenWithXShapeInferMeta(const MetaTensor& x,
                                int start_axis,
                                int stop_axis,
                                MetaTensor* out,
                                MetaTensor* xshape);

101 102 103 104
void FlipInferMeta(const MetaTensor& x,
                   const std::vector<int>& axis,
                   MetaTensor* out);

105 106 107 108 109 110 111 112
void FullBatchSizeLikeInferMeta(const MetaTensor& x,
                                const std::vector<int>& shape,
                                const Scalar& val,
                                DataType dtype,
                                int x_batch_size_dim,
                                int out_batch_size_dim,
                                MetaTensor* out);

Z
zyfncg 已提交
113 114 115 116 117
void GumbelSoftmaxInferMeta(const MetaTensor& x,
                            float temperature,
                            bool hard,
                            int axis,
                            MetaTensor* out);
H
hong 已提交
118 119
void HistogramInferMeta(
    const MetaTensor& input, int64_t bins, int min, int max, MetaTensor* out);
Z
zyfncg 已提交
120

121 122
void IncrementInferMeta(const MetaTensor& x, float value, MetaTensor* out);

123 124 125
void InferMetaFromVecValue(const MetaTensor& x,
                           const std::vector<int64_t>& shape,
                           MetaTensor* out);
126

W
WJJ1995 已提交
127 128
void IsEmptyInferMeta(const MetaTensor& x, MetaTensor* out);

Z
zyfncg 已提交
129 130
void IsfiniteInferMeta(const MetaTensor& input, MetaTensor* out);

131 132 133 134 135 136 137 138
void KthvalueInferMeta(const MetaTensor& x,
                       int k,
                       int axis,
                       bool keepdim,
                       MetaTensor* out,
                       MetaTensor* indices,
                       MetaConfig = MetaConfig());

139 140
void MatrixPowerInferMeta(const MetaTensor& x, int n, MetaTensor* out);

141 142 143 144 145
void MaxOutInferMeta(const MetaTensor& x,
                     int groups,
                     int axis,
                     MetaTensor* out);

F
From00 已提交
146 147 148 149 150 151 152 153 154 155
void MaxPoolWithIndexInferMeta(const MetaTensor& x,
                               const std::vector<int>& kernel_size,
                               const std::vector<int>& strides,
                               const std::vector<int>& paddings,
                               bool global_pooling,
                               bool adaptive,
                               MetaTensor* out,
                               MetaTensor* mask,
                               MetaConfig config = MetaConfig());

156 157
void MeanAllInferMeta(const MetaTensor& x, MetaTensor* out);

158 159 160 161 162 163
void ModeInferMeta(const MetaTensor& x,
                   int axis,
                   bool keepdim,
                   MetaTensor* out,
                   MetaTensor* indices);

164 165 166 167
void MultinomialInferMeta(const MetaTensor& x,
                          int num_samples,
                          bool replacement,
                          MetaTensor* out);
H
hong 已提交
168 169 170 171 172 173
void NormInferMeta(const MetaTensor& x,
                   int axis,
                   float epsilon,
                   bool is_test,
                   MetaTensor* out,
                   MetaTensor* norm);
174

Z
zyfncg 已提交
175 176 177 178 179 180
void PadInferMeta(const MetaTensor& input,
                  const std::vector<int>& paddings,
                  float pad_value,
                  MetaTensor* out,
                  MetaConfig config = MetaConfig());

181 182 183 184 185 186 187 188
void Pad3dInferMeta(const MetaTensor& x,
                    const ScalarArray& paddings,
                    const std::string& mode,
                    float value,
                    const std::string& data_format,
                    MetaTensor* out,
                    MetaConfig config = MetaConfig());

Z
zyfncg 已提交
189 190 191 192 193
void PixelShuffleInferMeta(const MetaTensor& x,
                           int upscale_factor,
                           const std::string& data_format,
                           MetaTensor* out);

194 195 196 197 198 199 200 201
void PNormInferMeta(const MetaTensor& x,
                    float porder,
                    int axis,
                    float epsilon,
                    bool keepdim,
                    bool asvector,
                    MetaTensor* out);

F
From00 已提交
202 203 204 205 206 207 208 209 210 211 212 213 214 215
void PoolInferMeta(const MetaTensor& x,
                   const std::vector<int>& kernel_size,
                   const std::vector<int>& strides,
                   const std::vector<int>& paddings,
                   bool ceil_mode,
                   bool exclusive,
                   const std::string& data_format,
                   const std::string& pooling_type,
                   bool global_pooling,
                   bool adaptive,
                   const std::string& padding_algorithm,
                   MetaTensor* out,
                   MetaConfig config = MetaConfig());

216 217 218 219 220
void QrInferMeta(const MetaTensor& x,
                 const std::string& mode,
                 MetaTensor* q,
                 MetaTensor* r);

Z
zyfncg 已提交
221 222 223 224 225 226 227 228 229 230 231 232 233
void RealAndImagInferMeta(const MetaTensor& x, MetaTensor* out);

void ReduceInferMeta(const MetaTensor& x,
                     const std::vector<int64_t>& axis,
                     bool keep_dim,
                     MetaTensor* out);

void ReduceInferMetaBase(const MetaTensor& x,
                         const std::vector<int64_t>& axis,
                         bool keep_dim,
                         bool reduce_all,
                         MetaTensor* out);

234 235
void ReshapeInferMeta(const MetaTensor& x,
                      const ScalarArray& shape,
236 237 238 239 240 241 242 243
                      MetaTensor* out,
                      MetaConfig config = MetaConfig());

void ReshapeWithXShapeInferMeta(const MetaTensor& x,
                                const ScalarArray& shape,
                                MetaTensor* xshape,
                                MetaTensor* out,
                                MetaConfig config = MetaConfig());
244

245 246 247 248
void ReverseInferMeta(const MetaTensor& x,
                      const std::vector<int>& axis,
                      MetaTensor* out);

C
chenenquan 已提交
249 250 251 252 253
void RollInferMeta(const MetaTensor& x,
                   const ScalarArray& shifts,
                   const std::vector<int64_t>& axis,
                   MetaTensor* out);

254 255
void SetValueInferMeta(const MetaTensor& x, MetaTensor* out);

256 257
void ShapeInferMeta(const MetaTensor& input, MetaTensor* out);

Z
zyfncg 已提交
258 259 260 261 262 263 264
void ShardIndexInferMeta(const MetaTensor& in,
                         int index_num,
                         int nshards,
                         int shard_id,
                         int ignore_value,
                         MetaTensor* out,
                         MetaConfig config = MetaConfig());
265

Z
zyfncg 已提交
266
void SizeInferMeta(const MetaTensor& input, MetaTensor* out);
267

Z
zyfncg 已提交
268
void SoftmaxInferMeta(const MetaTensor& x, int axis, MetaTensor* out);
269

Z
zyfncg 已提交
270 271 272 273 274
void SplitInferMeta(const MetaTensor& x_meta,
                    const ScalarArray& num_or_sections,
                    const Scalar& axis,
                    std::vector<MetaTensor*> out,
                    MetaConfig config = MetaConfig());
275

276 277 278 279 280
void SqueezeInferMeta(const MetaTensor& x,
                      const std::vector<int>& axes,
                      MetaTensor* xshape,
                      MetaTensor* out);

281 282 283 284 285 286 287 288 289 290
void StridedSliceInferMeta(const MetaTensor& x,
                           const std::vector<int>& axes,
                           const ScalarArray& starts,
                           const ScalarArray& ends,
                           const ScalarArray& strides,
                           const std::vector<int>& infer_flags,
                           const std::vector<int>& decrease_axis,
                           MetaTensor* out,
                           MetaConfig config = MetaConfig());

291 292 293 294 295
void SumInferMeta(const MetaTensor& x,
                  const std::vector<int64_t>& axis,
                  DataType dtype,
                  bool keep_dim,
                  MetaTensor* out);
296

Z
zyfncg 已提交
297 298 299 300 301 302 303 304 305 306 307 308
void SumRawInferMeta(const MetaTensor& x,
                     const std::vector<int64_t>& axis,
                     bool keep_dim,
                     bool reduce_all,
                     DataType dtype,
                     MetaTensor* out);

void TileInferMeta(const MetaTensor& x,
                   const ScalarArray& repeat_times,
                   MetaTensor* out,
                   MetaConfig config = MetaConfig());

309 310 311 312 313 314 315 316 317
void TopKInferMeta(const MetaTensor& x,
                   const Scalar& k_scalar,
                   int axis,
                   bool largest,
                   bool sorted,
                   MetaTensor* out,
                   MetaTensor* indices,
                   MetaConfig config = MetaConfig());

Z
zyfncg 已提交
318 319 320
void TraceInferMeta(
    const MetaTensor& x, int offset, int axis1, int axis2, MetaTensor* out);

321 322 323 324
void TransferLayoutInferMeta(const MetaTensor& x,
                             DataLayout layout,
                             MetaTensor* out);

Z
zyfncg 已提交
325 326 327
void TransposeInferMeta(const MetaTensor& x,
                        const std::vector<int>& axis,
                        MetaTensor* out);
C
Chen Weihang 已提交
328

H
hong 已提交
329 330 331 332
void TransposeGradInferMeta(const MetaTensor& x,
                            const std::vector<int>& axis,
                            MetaTensor* out);

333 334 335 336 337
void TrilTriuInferMeta(const MetaTensor& x,
                       int diagonal,
                       bool lower,
                       MetaTensor* out);

L
Leo Chen 已提交
338 339 340
void UnbindInferMeta(const MetaTensor& x,
                     int axis,
                     std::vector<MetaTensor>* outs);
Z
zyfncg 已提交
341 342 343 344 345 346 347

void UnchangedInferMeta(const MetaTensor& x, MetaTensor* out);

// meta x -> out without change, check if axis in range [-Rank(x), Rank(x)-1]
void UnchangedInferMetaCheckAxis(const MetaTensor& x,
                                 int axis,
                                 MetaTensor* out);
C
Chen Weihang 已提交
348

349 350 351 352 353 354 355
void UnfoldInferMeta(const MetaTensor& x,
                     const std::vector<int>& kernel_sizes,
                     const std::vector<int>& strides,
                     const std::vector<int>& paddings,
                     const std::vector<int>& dilations,
                     MetaTensor* out,
                     MetaConfig config = MetaConfig());
356

357 358 359 360 361
void UnsqueezeInferMeta(const MetaTensor& x,
                        const ScalarArray& axes,
                        MetaTensor* xshape,
                        MetaTensor* out);

H
hong 已提交
362 363 364 365 366 367 368 369
void OneHotRawInferMeta(const MetaTensor& x,
                        int32_t depth,
                        DataType dtype,
                        bool allow_out_of_range,
                        MetaTensor* out);

void OneHotInferMeta(const MetaTensor& x, const Scalar& depth, MetaTensor* out);

370 371
void WhereIndexInferMeta(const MetaTensor& condition, MetaTensor* out);

372
}  // namespace phi