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

117 118
void IncrementInferMeta(const MetaTensor& x, float value, MetaTensor* out);

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

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

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

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

135 136
void MatrixPowerInferMeta(const MetaTensor& x, int n, MetaTensor* out);

F
From00 已提交
137 138 139 140 141 142 143 144 145 146
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());

147 148 149 150 151 152
void ModeInferMeta(const MetaTensor& x,
                   int axis,
                   bool keepdim,
                   MetaTensor* out,
                   MetaTensor* indices);

153 154 155 156
void MultinomialInferMeta(const MetaTensor& x,
                          int num_samples,
                          bool replacement,
                          MetaTensor* out);
H
hong 已提交
157 158 159 160 161 162
void NormInferMeta(const MetaTensor& x,
                   int axis,
                   float epsilon,
                   bool is_test,
                   MetaTensor* out,
                   MetaTensor* norm);
163

Z
zyfncg 已提交
164 165 166 167 168 169
void PadInferMeta(const MetaTensor& input,
                  const std::vector<int>& paddings,
                  float pad_value,
                  MetaTensor* out,
                  MetaConfig config = MetaConfig());

170 171 172 173 174 175 176 177
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 已提交
178 179 180 181 182
void PixelShuffleInferMeta(const MetaTensor& x,
                           int upscale_factor,
                           const std::string& data_format,
                           MetaTensor* out);

183 184 185 186 187 188 189 190
void PNormInferMeta(const MetaTensor& x,
                    float porder,
                    int axis,
                    float epsilon,
                    bool keepdim,
                    bool asvector,
                    MetaTensor* out);

F
From00 已提交
191 192 193 194 195 196 197 198 199 200 201 202 203 204
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());

205 206 207 208 209
void QrInferMeta(const MetaTensor& x,
                 const std::string& mode,
                 MetaTensor* q,
                 MetaTensor* r);

Z
zyfncg 已提交
210 211 212 213 214 215 216 217 218 219 220 221 222
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);

223 224
void ReshapeInferMeta(const MetaTensor& x,
                      const ScalarArray& shape,
225 226 227 228 229 230 231 232
                      MetaTensor* out,
                      MetaConfig config = MetaConfig());

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

234 235 236 237
void ReverseInferMeta(const MetaTensor& x,
                      const std::vector<int>& axis,
                      MetaTensor* out);

C
chenenquan 已提交
238 239 240 241 242
void RollInferMeta(const MetaTensor& x,
                   const ScalarArray& shifts,
                   const std::vector<int64_t>& axis,
                   MetaTensor* out);

243 244
void SetValueInferMeta(const MetaTensor& x, MetaTensor* out);

245 246
void ShapeInferMeta(const MetaTensor& input, MetaTensor* out);

Z
zyfncg 已提交
247 248 249 250 251 252 253
void ShardIndexInferMeta(const MetaTensor& in,
                         int index_num,
                         int nshards,
                         int shard_id,
                         int ignore_value,
                         MetaTensor* out,
                         MetaConfig config = MetaConfig());
254

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

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

Z
zyfncg 已提交
259 260 261 262 263
void SplitInferMeta(const MetaTensor& x_meta,
                    const ScalarArray& num_or_sections,
                    const Scalar& axis,
                    std::vector<MetaTensor*> out,
                    MetaConfig config = MetaConfig());
264

265 266 267 268 269
void SqueezeInferMeta(const MetaTensor& x,
                      const std::vector<int>& axes,
                      MetaTensor* xshape,
                      MetaTensor* out);

270 271 272 273 274
void SumInferMeta(const MetaTensor& x,
                  const std::vector<int64_t>& axis,
                  DataType dtype,
                  bool keep_dim,
                  MetaTensor* out);
275

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

288 289 290 291 292 293 294 295 296
void TopKInferMeta(const MetaTensor& x,
                   const Scalar& k_scalar,
                   int axis,
                   bool largest,
                   bool sorted,
                   MetaTensor* out,
                   MetaTensor* indices,
                   MetaConfig config = MetaConfig());

Z
zyfncg 已提交
297 298 299
void TraceInferMeta(
    const MetaTensor& x, int offset, int axis1, int axis2, MetaTensor* out);

300 301 302 303
void TransferLayoutInferMeta(const MetaTensor& x,
                             DataLayout layout,
                             MetaTensor* out);

Z
zyfncg 已提交
304 305 306
void TransposeInferMeta(const MetaTensor& x,
                        const std::vector<int>& axis,
                        MetaTensor* out);
C
Chen Weihang 已提交
307

H
hong 已提交
308 309 310 311
void TransposeGradInferMeta(const MetaTensor& x,
                            const std::vector<int>& axis,
                            MetaTensor* out);

312 313 314 315 316
void TrilTriuInferMeta(const MetaTensor& x,
                       int diagonal,
                       bool lower,
                       MetaTensor* out);

L
Leo Chen 已提交
317 318 319
void UnbindInferMeta(const MetaTensor& x,
                     int axis,
                     std::vector<MetaTensor>* outs);
Z
zyfncg 已提交
320 321 322 323 324 325 326

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

328 329 330 331 332 333 334
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());
335

336 337 338 339 340
void UnsqueezeInferMeta(const MetaTensor& x,
                        const ScalarArray& axes,
                        MetaTensor* xshape,
                        MetaTensor* out);

H
hong 已提交
341 342 343 344 345 346 347 348
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);

349 350
void WhereIndexInferMeta(const MetaTensor& condition, MetaTensor* out);

351
}  // namespace phi