unary.h 15.8 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
#include "paddle/phi/common/int_array.h"
19 20
#include "paddle/phi/common/scalar.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 83 84 85 86 87 88 89 90 91 92
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);

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);

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

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

103 104 105 106 107 108 109 110
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 已提交
111 112 113 114 115
void GumbelSoftmaxInferMeta(const MetaTensor& x,
                            float temperature,
                            bool hard,
                            int axis,
                            MetaTensor* out);
H
hong 已提交
116 117
void HistogramInferMeta(
    const MetaTensor& input, int64_t bins, int min, int max, MetaTensor* out);
Z
zyfncg 已提交
118

119 120
void IncrementInferMeta(const MetaTensor& x, float value, MetaTensor* out);

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

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

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

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

137 138 139 140 141 142
void LogsumexpInferMeta(const MetaTensor& input,
                        const std::vector<int64_t>& axis,
                        bool keepdim,
                        bool reduce_all,
                        MetaTensor* out);

143 144
void MatrixPowerInferMeta(const MetaTensor& x, int n, MetaTensor* out);

145 146 147 148 149
void MaxOutInferMeta(const MetaTensor& x,
                     int groups,
                     int axis,
                     MetaTensor* out);

F
From00 已提交
150 151 152 153 154 155 156 157 158 159
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());

160 161
void MeanAllInferMeta(const MetaTensor& x, MetaTensor* out);

162 163 164 165 166 167
void ModeInferMeta(const MetaTensor& x,
                   int axis,
                   bool keepdim,
                   MetaTensor* out,
                   MetaTensor* indices);

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

Z
zyfncg 已提交
179 180 181 182 183 184
void PadInferMeta(const MetaTensor& input,
                  const std::vector<int>& paddings,
                  float pad_value,
                  MetaTensor* out,
                  MetaConfig config = MetaConfig());

185
void Pad3dInferMeta(const MetaTensor& x,
186
                    const IntArray& paddings,
187 188 189 190 191 192
                    const std::string& mode,
                    float value,
                    const std::string& data_format,
                    MetaTensor* out,
                    MetaConfig config = MetaConfig());

Z
zyfncg 已提交
193 194 195 196 197
void PixelShuffleInferMeta(const MetaTensor& x,
                           int upscale_factor,
                           const std::string& data_format,
                           MetaTensor* out);

198 199 200 201 202 203 204 205
void PNormInferMeta(const MetaTensor& x,
                    float porder,
                    int axis,
                    float epsilon,
                    bool keepdim,
                    bool asvector,
                    MetaTensor* out);

F
From00 已提交
206 207 208 209 210 211 212 213 214 215 216 217 218 219
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());

220 221 222 223 224
void QrInferMeta(const MetaTensor& x,
                 const std::string& mode,
                 MetaTensor* q,
                 MetaTensor* r);

Z
zyfncg 已提交
225 226 227 228 229 230 231 232 233 234 235 236 237
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);

238
void ReshapeInferMeta(const MetaTensor& x,
239
                      const IntArray& shape,
240 241 242 243
                      MetaTensor* out,
                      MetaConfig config = MetaConfig());

void ReshapeWithXShapeInferMeta(const MetaTensor& x,
244
                                const IntArray& shape,
245
                                MetaTensor* out,
246
                                MetaTensor* xshape,
247
                                MetaConfig config = MetaConfig());
248

249 250 251 252
void ReverseInferMeta(const MetaTensor& x,
                      const std::vector<int>& axis,
                      MetaTensor* out);

C
chenenquan 已提交
253
void RollInferMeta(const MetaTensor& x,
254
                   const IntArray& shifts,
C
chenenquan 已提交
255 256 257
                   const std::vector<int64_t>& axis,
                   MetaTensor* out);

258 259
void SetValueInferMeta(const MetaTensor& x, MetaTensor* out);

260 261
void ShapeInferMeta(const MetaTensor& input, MetaTensor* out);

Z
zyfncg 已提交
262 263 264 265 266 267 268
void ShardIndexInferMeta(const MetaTensor& in,
                         int index_num,
                         int nshards,
                         int shard_id,
                         int ignore_value,
                         MetaTensor* out,
                         MetaConfig config = MetaConfig());
269

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

H
hong 已提交
272 273 274 275 276 277 278 279 280
void SliceRawInferMeta(const MetaTensor& input,
                       const std::vector<int64_t>& axes,
                       const IntArray& starts,
                       const IntArray& ends,
                       const std::vector<int64_t>& infer_flags,
                       const std::vector<int64_t>& decrease_axis,
                       MetaTensor* out,
                       MetaConfig config = MetaConfig());

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

Z
zyfncg 已提交
283
void SplitInferMeta(const MetaTensor& x_meta,
284
                    const IntArray& num_or_sections,
Z
zyfncg 已提交
285 286 287
                    const Scalar& axis,
                    std::vector<MetaTensor*> out,
                    MetaConfig config = MetaConfig());
288

289 290 291 292 293
void SqueezeInferMeta(const MetaTensor& x,
                      const std::vector<int>& axes,
                      MetaTensor* xshape,
                      MetaTensor* out);

294 295 296 297 298 299 300 301 302 303
void StridedSliceRawInferMeta(const MetaTensor& x,
                              const std::vector<int>& axes,
                              const IntArray& starts,
                              const IntArray& ends,
                              const IntArray& strides,
                              const std::vector<int>& infer_flags,
                              const std::vector<int>& decrease_axis,
                              MetaTensor* out,
                              MetaConfig config = MetaConfig());

304 305
void StridedSliceInferMeta(const MetaTensor& x,
                           const std::vector<int>& axes,
306 307 308
                           const IntArray& starts,
                           const IntArray& ends,
                           const IntArray& strides,
309 310 311
                           MetaTensor* out,
                           MetaConfig config = MetaConfig());

312 313 314 315 316
void SumInferMeta(const MetaTensor& x,
                  const std::vector<int64_t>& axis,
                  DataType dtype,
                  bool keep_dim,
                  MetaTensor* out);
317

Z
zyfncg 已提交
318 319 320 321 322 323 324
void SumRawInferMeta(const MetaTensor& x,
                     const std::vector<int64_t>& axis,
                     bool keep_dim,
                     bool reduce_all,
                     DataType dtype,
                     MetaTensor* out);

H
hong 已提交
325 326 327 328 329 330 331
void TemporalShiftInferMeta(const MetaTensor& x,
                            int seg_num,
                            float shift_ratio,
                            const std::string& data_format,
                            MetaTensor* out,
                            MetaConfig config = MetaConfig());

Z
zyfncg 已提交
332
void TileInferMeta(const MetaTensor& x,
333
                   const IntArray& repeat_times,
Z
zyfncg 已提交
334 335 336
                   MetaTensor* out,
                   MetaConfig config = MetaConfig());

337 338 339 340 341 342 343 344 345
void TopKInferMeta(const MetaTensor& x,
                   const Scalar& k_scalar,
                   int axis,
                   bool largest,
                   bool sorted,
                   MetaTensor* out,
                   MetaTensor* indices,
                   MetaConfig config = MetaConfig());

Z
zyfncg 已提交
346 347 348
void TraceInferMeta(
    const MetaTensor& x, int offset, int axis1, int axis2, MetaTensor* out);

349 350 351 352
void TransferLayoutInferMeta(const MetaTensor& x,
                             DataLayout layout,
                             MetaTensor* out);

Z
zyfncg 已提交
353 354 355
void TransposeInferMeta(const MetaTensor& x,
                        const std::vector<int>& axis,
                        MetaTensor* out);
C
Chen Weihang 已提交
356

H
hong 已提交
357 358 359 360
void TransposeGradInferMeta(const MetaTensor& x,
                            const std::vector<int>& axis,
                            MetaTensor* out);

361 362 363 364 365
void TrilTriuInferMeta(const MetaTensor& x,
                       int diagonal,
                       bool lower,
                       MetaTensor* out);

L
Leo Chen 已提交
366 367 368
void UnbindInferMeta(const MetaTensor& x,
                     int axis,
                     std::vector<MetaTensor>* outs);
Z
zyfncg 已提交
369 370 371 372 373 374 375

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 已提交
376

377 378 379 380 381 382 383
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());
384

C
csy0225 已提交
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
void UniqueInferMeta(const MetaTensor& x,
                     bool return_index,
                     bool return_inverse,
                     bool return_counts,
                     const std::vector<int>& axis,
                     DataType dtype,
                     MetaTensor* out,
                     MetaTensor* indices,
                     MetaTensor* index,
                     MetaTensor* counts);

void UniqueRawInferMeta(const MetaTensor& x,
                        bool return_index,
                        bool return_inverse,
                        bool return_counts,
                        const std::vector<int>& axis,
                        DataType dtype,
                        bool is_sorted,
                        MetaTensor* out,
                        MetaTensor* indices,
                        MetaTensor* index,
                        MetaTensor* counts);

408
void UnsqueezeInferMeta(const MetaTensor& x,
409
                        const IntArray& axes,
410
                        MetaTensor* xshape,
411 412
                        MetaTensor* out,
                        MetaConfig config = MetaConfig());
413

C
csy0225 已提交
414 415 416 417 418
void UnStackInferMeta(const MetaTensor& x,
                      int axis,
                      int num,
                      std::vector<MetaTensor*> outs);

H
hong 已提交
419 420 421 422 423 424 425 426
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);

427 428
void WhereIndexInferMeta(const MetaTensor& condition, MetaTensor* out);

429
}  // namespace phi