unary.h 19.3 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
void AsRealInferMeta(const MetaTensor& input, MetaTensor* output);

53 54
void AsComplexInferMeta(const MetaTensor& input, MetaTensor* output);

55 56 57 58 59 60
void BatchSizeLikeInferMeta(const MetaTensor& x,
                            const std::vector<int>& shape,
                            int x_batch_size_dim,
                            int out_batch_size_dim,
                            MetaTensor* out);

61
void CastInferMeta(const MetaTensor& x, DataType out_dtype, MetaTensor* out);
62

63 64
void CholeskyInferMeta(const MetaTensor& x, bool upper, MetaTensor* out);

L
lyq 已提交
65 66
void ClipByNormInferMeta(const MetaTensor& x, float max_norm, MetaTensor* out);

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

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

76 77 78
void DiagEmbedInferMeta(
    const MetaTensor& x, int offset, int dim1, int dim2, MetaTensor* out);

Z
zyfncg 已提交
79 80 81 82 83 84 85 86
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);

87 88
void EigInferMeta(const MetaTensor& x, MetaTensor* out_w, MetaTensor* out_v);

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

R
Ruibiao Chen 已提交
94 95 96 97
void EigvalsInferMeta(const MetaTensor& x,
                      MetaTensor* out,
                      MetaConfig config = MetaConfig());

98 99
void EinsumInferMeta(const std::vector<const MetaTensor*>& inputs,
                     const std::string& equation,
100 101 102 103 104 105 106
                     MetaTensor* out);

void EinsumRawInferMeta(const std::vector<const MetaTensor*>& inputs,
                        const std::string& equation,
                        MetaTensor* out,
                        std::vector<MetaTensor*> inner_cache,
                        std::vector<MetaTensor*> xshape);
107

H
hong 已提交
108 109 110 111
void ExpandInferMeta(const MetaTensor& x,
                     const IntArray& shape,
                     MetaTensor* out);

Z
zyfncg 已提交
112 113 114 115 116
void FlattenInferMeta(const MetaTensor& x,
                      int start_axis,
                      int stop_axis,
                      MetaTensor* out);

117 118 119 120 121 122
void FlattenWithXShapeInferMeta(const MetaTensor& x,
                                int start_axis,
                                int stop_axis,
                                MetaTensor* out,
                                MetaTensor* xshape);

123 124 125 126
void FlipInferMeta(const MetaTensor& x,
                   const std::vector<int>& axis,
                   MetaTensor* out);

127 128 129 130 131 132 133 134
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 已提交
135 136 137 138 139
void GumbelSoftmaxInferMeta(const MetaTensor& x,
                            float temperature,
                            bool hard,
                            int axis,
                            MetaTensor* out);
H
hong 已提交
140 141
void HistogramInferMeta(
    const MetaTensor& input, int64_t bins, int min, int max, MetaTensor* out);
Z
zyfncg 已提交
142

143 144
void IncrementInferMeta(const MetaTensor& x, float value, MetaTensor* out);

145 146 147
void InferMetaFromVecValue(const MetaTensor& x,
                           const std::vector<int64_t>& shape,
                           MetaTensor* out);
148

149 150
void InverseInferMeta(const MetaTensor& x, MetaTensor* out);

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

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

155 156 157 158 159 160 161 162
void KthvalueInferMeta(const MetaTensor& x,
                       int k,
                       int axis,
                       bool keepdim,
                       MetaTensor* out,
                       MetaTensor* indices,
                       MetaConfig = MetaConfig());

163 164 165 166 167 168
void LogsumexpInferMeta(const MetaTensor& input,
                        const std::vector<int64_t>& axis,
                        bool keepdim,
                        bool reduce_all,
                        MetaTensor* out);

169 170
void MatrixPowerInferMeta(const MetaTensor& x, int n, MetaTensor* out);

171 172 173 174 175
void MatrixRankInferMeta(const MetaTensor& x,
                         bool use_default_tol,
                         bool hermitian,
                         MetaTensor* out);

176 177 178 179 180
void MaxOutInferMeta(const MetaTensor& x,
                     int groups,
                     int axis,
                     MetaTensor* out);

F
From00 已提交
181 182 183 184 185 186 187 188 189 190
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());

191 192
void MeanAllInferMeta(const MetaTensor& x, MetaTensor* out);

193 194 195 196 197 198
void ModeInferMeta(const MetaTensor& x,
                   int axis,
                   bool keepdim,
                   MetaTensor* out,
                   MetaTensor* indices);

199 200 201 202
void MultinomialInferMeta(const MetaTensor& x,
                          int num_samples,
                          bool replacement,
                          MetaTensor* out);
203 204 205 206 207 208 209

void NanmedianInferMeta(const MetaTensor& x,
                        const IntArray& axes,
                        bool keep_dim,
                        MetaTensor* out,
                        MetaTensor* median_index);

H
hong 已提交
210 211 212 213 214 215
void NormInferMeta(const MetaTensor& x,
                   int axis,
                   float epsilon,
                   bool is_test,
                   MetaTensor* out,
                   MetaTensor* norm);
216

Z
zyfncg 已提交
217 218 219 220 221 222
void PadInferMeta(const MetaTensor& input,
                  const std::vector<int>& paddings,
                  float pad_value,
                  MetaTensor* out,
                  MetaConfig config = MetaConfig());

223
void Pad3dInferMeta(const MetaTensor& x,
224
                    const IntArray& paddings,
225 226 227 228 229 230
                    const std::string& mode,
                    float value,
                    const std::string& data_format,
                    MetaTensor* out,
                    MetaConfig config = MetaConfig());

Z
zyfncg 已提交
231 232 233 234 235
void PixelShuffleInferMeta(const MetaTensor& x,
                           int upscale_factor,
                           const std::string& data_format,
                           MetaTensor* out);

H
hong 已提交
236 237 238 239 240
void PixelShuffleGradInferMeta(const MetaTensor& out_grad,
                               int upscale_factor,
                               const std::string& data_format,
                               MetaTensor* x_grad);

241 242 243 244 245
void PixelUnshuffleInferMeta(const MetaTensor& x,
                             int downscale_factor,
                             const std::string& data_format,
                             MetaTensor* out);

246 247 248 249 250 251 252 253
void PNormInferMeta(const MetaTensor& x,
                    float porder,
                    int axis,
                    float epsilon,
                    bool keepdim,
                    bool asvector,
                    MetaTensor* out);

F
From00 已提交
254 255 256 257 258 259 260 261 262 263 264 265 266 267
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());

268 269 270 271 272
void QrInferMeta(const MetaTensor& x,
                 const std::string& mode,
                 MetaTensor* q,
                 MetaTensor* r);

Z
zyfncg 已提交
273 274 275 276 277 278 279 280 281 282 283 284 285
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);

286
void ReshapeInferMeta(const MetaTensor& x,
287
                      const IntArray& shape,
288 289 290 291
                      MetaTensor* out,
                      MetaConfig config = MetaConfig());

void ReshapeWithXShapeInferMeta(const MetaTensor& x,
292
                                const IntArray& shape,
293
                                MetaTensor* out,
294
                                MetaTensor* xshape,
295
                                MetaConfig config = MetaConfig());
296

297 298 299 300
void ReverseInferMeta(const MetaTensor& x,
                      const std::vector<int>& axis,
                      MetaTensor* out);

C
chenenquan 已提交
301
void RollInferMeta(const MetaTensor& x,
302
                   const IntArray& shifts,
C
chenenquan 已提交
303 304 305
                   const std::vector<int64_t>& axis,
                   MetaTensor* out);

306 307 308 309 310 311 312 313 314 315 316
void RReluInferMeta(const MetaTensor& x,
                    float lower,
                    float upper,
                    bool is_test,
                    MetaTensor* out,
                    MetaTensor* noise);

void RReluGradInferMeta(const MetaTensor& out_grad,
                        const MetaTensor& noise,
                        MetaTensor* x_grad);

317 318
void SetValueInferMeta(const MetaTensor& x, MetaTensor* out);

319 320
void ShapeInferMeta(const MetaTensor& input, MetaTensor* out);

Z
zyfncg 已提交
321 322 323 324 325 326 327
void ShardIndexInferMeta(const MetaTensor& in,
                         int index_num,
                         int nshards,
                         int shard_id,
                         int ignore_value,
                         MetaTensor* out,
                         MetaConfig config = MetaConfig());
328

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

H
hong 已提交
331 332 333 334 335 336 337 338 339
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 已提交
340
void SoftmaxInferMeta(const MetaTensor& x, int axis, MetaTensor* out);
341

Z
zyfncg 已提交
342
void SplitInferMeta(const MetaTensor& x_meta,
343
                    const IntArray& num_or_sections,
Z
zyfncg 已提交
344 345 346
                    const Scalar& axis,
                    std::vector<MetaTensor*> out,
                    MetaConfig config = MetaConfig());
347

348 349
void SquaredL2NormInferMeta(const MetaTensor& x, MetaTensor* out);

350 351
void SqueezeInferMeta(const MetaTensor& x,
                      const std::vector<int>& axes,
352 353 354 355 356 357
                      MetaTensor* out);

void SqueezeWithXShapeInferMeta(const MetaTensor& x,
                                const std::vector<int>& axes,
                                MetaTensor* out,
                                MetaTensor* xshape);
358

359 360 361 362 363 364 365 366 367 368
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());

369 370
void StridedSliceInferMeta(const MetaTensor& x,
                           const std::vector<int>& axes,
371 372 373
                           const IntArray& starts,
                           const IntArray& ends,
                           const IntArray& strides,
374 375 376
                           MetaTensor* out,
                           MetaConfig config = MetaConfig());

377 378 379 380 381
void SumInferMeta(const MetaTensor& x,
                  const std::vector<int64_t>& axis,
                  DataType dtype,
                  bool keep_dim,
                  MetaTensor* out);
382

Z
zyfncg 已提交
383 384 385 386 387 388 389
void SumRawInferMeta(const MetaTensor& x,
                     const std::vector<int64_t>& axis,
                     bool keep_dim,
                     bool reduce_all,
                     DataType dtype,
                     MetaTensor* out);

390 391 392 393 394 395
void SvdInferMeta(const MetaTensor& x,
                  bool full_matrices,
                  MetaTensor* u,
                  MetaTensor* s,
                  MetaTensor* vh);

H
hong 已提交
396 397 398 399 400 401 402
void TemporalShiftInferMeta(const MetaTensor& x,
                            int seg_num,
                            float shift_ratio,
                            const std::string& data_format,
                            MetaTensor* out,
                            MetaConfig config = MetaConfig());

Z
zyfncg 已提交
403
void TileInferMeta(const MetaTensor& x,
404
                   const IntArray& repeat_times,
Z
zyfncg 已提交
405 406 407
                   MetaTensor* out,
                   MetaConfig config = MetaConfig());

408 409 410 411 412 413 414 415 416
void TopKInferMeta(const MetaTensor& x,
                   const Scalar& k_scalar,
                   int axis,
                   bool largest,
                   bool sorted,
                   MetaTensor* out,
                   MetaTensor* indices,
                   MetaConfig config = MetaConfig());

Z
zyfncg 已提交
417 418 419
void TraceInferMeta(
    const MetaTensor& x, int offset, int axis1, int axis2, MetaTensor* out);

420 421 422 423
void TransferLayoutInferMeta(const MetaTensor& x,
                             DataLayout layout,
                             MetaTensor* out);

Z
zyfncg 已提交
424 425 426
void TransposeInferMeta(const MetaTensor& x,
                        const std::vector<int>& axis,
                        MetaTensor* out);
C
Chen Weihang 已提交
427

H
hong 已提交
428 429 430 431
void TransposeGradInferMeta(const MetaTensor& x,
                            const std::vector<int>& axis,
                            MetaTensor* out);

432 433 434 435 436
void TrilTriuInferMeta(const MetaTensor& x,
                       int diagonal,
                       bool lower,
                       MetaTensor* out);

L
Leo Chen 已提交
437 438
void UnbindInferMeta(const MetaTensor& x,
                     int axis,
439
                     std::vector<MetaTensor*> outs);
Z
zyfncg 已提交
440 441 442 443 444 445 446

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

448 449 450 451 452 453 454
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());
455

456 457 458 459 460 461 462 463 464
void UniqueConsecutiveInferMeta(const MetaTensor& x,
                                bool return_inverse,
                                bool return_counts,
                                const std::vector<int>& axis,
                                int dtype,
                                MetaTensor* out,
                                MetaTensor* index,
                                MetaTensor* counts);

C
csy0225 已提交
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
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);

488
void UnsqueezeInferMeta(const MetaTensor& x,
489
                        const IntArray& axes,
490 491
                        MetaTensor* out,
                        MetaConfig config = MetaConfig());
492

493 494 495 496 497 498
void UnsqueezeWithXShapeInferMeta(const MetaTensor& x,
                                  const IntArray& axes,
                                  MetaTensor* out,
                                  MetaTensor* xshape,
                                  MetaConfig config = MetaConfig());

C
csy0225 已提交
499 500 501 502 503
void UnStackInferMeta(const MetaTensor& x,
                      int axis,
                      int num,
                      std::vector<MetaTensor*> outs);

H
hong 已提交
504
void OneHotRawInferMeta(const MetaTensor& x,
505
                        const Scalar& depth,
H
hong 已提交
506 507 508 509 510 511
                        DataType dtype,
                        bool allow_out_of_range,
                        MetaTensor* out);

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

512 513
void WhereIndexInferMeta(const MetaTensor& condition, MetaTensor* out);

514 515 516 517 518
void ChannelShuffleInferMeta(const MetaTensor& x,
                             int groups,
                             const std::string& data_format,
                             MetaTensor* out);

519 520
void IdentityLossInferMeta(const MetaTensor& x, int reduction, MetaTensor* out);

521
}  // namespace phi