Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/tensorflow/python/ops/gen_nn_ops.py: 7%

1"""Python wrappers around TensorFlow ops. 

2 

3This file is MACHINE GENERATED! Do not edit. 

4""" 

5 

6import collections 

7 

8from tensorflow.python import pywrap_tfe as pywrap_tfe 

9from tensorflow.python.eager import context as _context 

10from tensorflow.python.eager import core as _core 

11from tensorflow.python.eager import execute as _execute 

12from tensorflow.python.framework import dtypes as _dtypes 

13from tensorflow.security.fuzzing.py import annotation_types as _atypes 

14 

15from tensorflow.python.framework import op_def_registry as _op_def_registry 

16from tensorflow.python.framework import ops as _ops 

17from tensorflow.python.framework import op_def_library as _op_def_library 

18from tensorflow.python.util.deprecation import deprecated_endpoints 

19from tensorflow.python.util import dispatch as _dispatch 

20from tensorflow.python.util.tf_export import tf_export 

21 

22from typing import TypeVar 

23_ApproxTopKOutput = collections.namedtuple( 

24 "ApproxTopK", 

25 ["values", "indices"]) 

26 

27 

28@_dispatch.add_fallback_dispatch_list 

29@_dispatch.add_type_based_api_dispatcher 

30@tf_export('approx_top_k') 

31def approx_top_k(input, k, reduction_dimension=-1, recall_target=0.95, is_max_k=True, reduction_input_size_override=-1, aggregate_to_topk=True, name=None): 

32 r"""Returns min/max k values and their indices of the input operand in an approximate manner. 

33 

34 See https://arxiv.org/abs/2206.14286 for the algorithm details. 

35 This op is only optimized on TPU currently. 

36 

37 Args: 

38 input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`. 

39 Array to search. Must be at least 1-D of the floating type 

40 k: An `int` that is `>= 0`. Specifies the number of min/max-k. 

41 reduction_dimension: An optional `int`. Defaults to `-1`. 

42 Integer dimension along which to search. Default: -1. 

43 recall_target: An optional `float`. Defaults to `0.95`. 

44 Recall target for the approximation. Range in (0,1] 

45 is_max_k: An optional `bool`. Defaults to `True`. 

46 When true, computes max-k; otherwise computes min-k. 

47 reduction_input_size_override: An optional `int`. Defaults to `-1`. 

48 When set to a positive value, it overrides the size determined by 

49 `input[reduction_dim]` for evaluating the recall. This option is useful when 

50 the given `input` is only a subset of the overall computation in SPMD or 

51 distributed pipelines, where the true input size cannot be deferred by the 

52 `input` shape. 

53 aggregate_to_topk: An optional `bool`. Defaults to `True`. 

54 When true, aggregates approximate results to top-k. When false, returns the 

55 approximate results. The number of the approximate results is implementation 

56 defined and is greater equals to the specified `k`. 

57 name: A name for the operation (optional). 

58 

59 Returns: 

60 A tuple of `Tensor` objects (values, indices). 

61 

62 values: A `Tensor`. Has the same type as `input`. 

63 indices: A `Tensor` of type `int32`. 

64 """ 

65 _ctx = _context._context or _context.context() 

66 tld = _ctx._thread_local_data 

67 if tld.is_eager: 

68 try: 

69 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

70 _ctx, "ApproxTopK", name, input, "k", k, "reduction_dimension", 

71 reduction_dimension, "recall_target", recall_target, "is_max_k", 

72 is_max_k, "reduction_input_size_override", 

73 reduction_input_size_override, "aggregate_to_topk", aggregate_to_topk) 

74 _result = _ApproxTopKOutput._make(_result) 

75 return _result 

76 except _core._NotOkStatusException as e: 

77 _ops.raise_from_not_ok_status(e, name) 

78 except _core._FallbackException: 

79 pass 

80 try: 

81 _result = _dispatcher_for_approx_top_k( 

82 (input, k, reduction_dimension, recall_target, is_max_k, 

83 reduction_input_size_override, aggregate_to_topk, name,), None) 

84 if _result is not NotImplemented: 

85 return _result 

86 return approx_top_k_eager_fallback( 

87 input, k=k, reduction_dimension=reduction_dimension, 

88 recall_target=recall_target, is_max_k=is_max_k, 

89 reduction_input_size_override=reduction_input_size_override, 

90 aggregate_to_topk=aggregate_to_topk, name=name, ctx=_ctx) 

91 except _core._SymbolicException: 

92 pass # Add nodes to the TensorFlow graph. 

93 except (TypeError, ValueError): 

94 _result = _dispatch.dispatch( 

95 approx_top_k, (), dict(input=input, k=k, 

96 reduction_dimension=reduction_dimension, 

97 recall_target=recall_target, 

98 is_max_k=is_max_k, 

99 reduction_input_size_override=reduction_input_size_override, 

100 aggregate_to_topk=aggregate_to_topk, 

101 name=name) 

102 ) 

103 if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED: 

104 return _result 

105 raise 

106 else: 

107 _result = _dispatcher_for_approx_top_k( 

108 (input, k, reduction_dimension, recall_target, is_max_k, 

109 reduction_input_size_override, aggregate_to_topk, name,), None) 

110 if _result is not NotImplemented: 

111 return _result 

112 # Add nodes to the TensorFlow graph. 

113 k = _execute.make_int(k, "k") 

114 if reduction_dimension is None: 

115 reduction_dimension = -1 

116 reduction_dimension = _execute.make_int(reduction_dimension, "reduction_dimension") 

117 if recall_target is None: 

118 recall_target = 0.95 

119 recall_target = _execute.make_float(recall_target, "recall_target") 

120 if is_max_k is None: 

121 is_max_k = True 

122 is_max_k = _execute.make_bool(is_max_k, "is_max_k") 

123 if reduction_input_size_override is None: 

124 reduction_input_size_override = -1 

125 reduction_input_size_override = _execute.make_int(reduction_input_size_override, "reduction_input_size_override") 

126 if aggregate_to_topk is None: 

127 aggregate_to_topk = True 

128 aggregate_to_topk = _execute.make_bool(aggregate_to_topk, "aggregate_to_topk") 

129 try: 

130 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

131 "ApproxTopK", input=input, k=k, 

132 reduction_dimension=reduction_dimension, 

133 recall_target=recall_target, is_max_k=is_max_k, 

134 reduction_input_size_override=reduction_input_size_override, 

135 aggregate_to_topk=aggregate_to_topk, name=name) 

136 except (TypeError, ValueError): 

137 _result = _dispatch.dispatch( 

138 approx_top_k, (), dict(input=input, k=k, 

139 reduction_dimension=reduction_dimension, 

140 recall_target=recall_target, 

141 is_max_k=is_max_k, 

142 reduction_input_size_override=reduction_input_size_override, 

143 aggregate_to_topk=aggregate_to_topk, 

144 name=name) 

145 ) 

146 if _result is not _dispatch.OpDispatcher.NOT_SUPPORTED: 

147 return _result 

148 raise 

149 _result = _outputs[:] 

150 if _execute.must_record_gradient(): 

151 _attrs = ("k", _op._get_attr_int("k"), "reduction_dimension", 

152 _op._get_attr_int("reduction_dimension"), "recall_target", 

153 _op.get_attr("recall_target"), "is_max_k", 

154 _op._get_attr_bool("is_max_k"), "reduction_input_size_override", 

155 _op._get_attr_int("reduction_input_size_override"), 

156 "aggregate_to_topk", _op._get_attr_bool("aggregate_to_topk"), 

157 "T", _op._get_attr_type("T")) 

158 _inputs_flat = _op.inputs 

159 _execute.record_gradient( 

160 "ApproxTopK", _inputs_flat, _attrs, _result) 

161 _result = _ApproxTopKOutput._make(_result) 

162 return _result 

163 

164ApproxTopK = tf_export("raw_ops.ApproxTopK")(_ops.to_raw_op(approx_top_k)) 

165_dispatcher_for_approx_top_k = approx_top_k._tf_type_based_dispatcher.Dispatch 

166 

167 

168def approx_top_k_eager_fallback(input, k, reduction_dimension, recall_target, is_max_k, reduction_input_size_override, aggregate_to_topk, name, ctx): 

169 k = _execute.make_int(k, "k") 

170 if reduction_dimension is None: 

171 reduction_dimension = -1 

172 reduction_dimension = _execute.make_int(reduction_dimension, "reduction_dimension") 

173 if recall_target is None: 

174 recall_target = 0.95 

175 recall_target = _execute.make_float(recall_target, "recall_target") 

176 if is_max_k is None: 

177 is_max_k = True 

178 is_max_k = _execute.make_bool(is_max_k, "is_max_k") 

179 if reduction_input_size_override is None: 

180 reduction_input_size_override = -1 

181 reduction_input_size_override = _execute.make_int(reduction_input_size_override, "reduction_input_size_override") 

182 if aggregate_to_topk is None: 

183 aggregate_to_topk = True 

184 aggregate_to_topk = _execute.make_bool(aggregate_to_topk, "aggregate_to_topk") 

185 _attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, ]) 

186 _inputs_flat = [input] 

187 _attrs = ("k", k, "reduction_dimension", reduction_dimension, 

188 "recall_target", recall_target, "is_max_k", is_max_k, 

189 "reduction_input_size_override", reduction_input_size_override, 

190 "aggregate_to_topk", aggregate_to_topk, "T", _attr_T) 

191 _result = _execute.execute(b"ApproxTopK", 2, inputs=_inputs_flat, 

192 attrs=_attrs, ctx=ctx, name=name) 

193 if _execute.must_record_gradient(): 

194 _execute.record_gradient( 

195 "ApproxTopK", _inputs_flat, _attrs, _result) 

196 _result = _ApproxTopKOutput._make(_result) 

197 return _result 

198 

199 

200def avg_pool(value, ksize, strides, padding, data_format="NHWC", name=None): 

201 r"""Performs average pooling on the input. 

202 

203 Each entry in `output` is the mean of the corresponding size `ksize` 

204 window in `value`. 

205 

206 Args: 

207 value: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 

208 4-D with shape `[batch, height, width, channels]`. 

209 ksize: A list of `ints` that has length `>= 4`. 

210 The size of the sliding window for each dimension of `value`. 

211 strides: A list of `ints` that has length `>= 4`. 

212 The stride of the sliding window for each dimension of `value`. 

213 padding: A `string` from: `"SAME", "VALID"`. 

214 The type of padding algorithm to use. 

215 data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. 

216 Specify the data format of the input and output data. With the 

217 default format "NHWC", the data is stored in the order of: 

218 [batch, in_height, in_width, in_channels]. 

219 Alternatively, the format could be "NCHW", the data storage order of: 

220 [batch, in_channels, in_height, in_width]. 

221 name: A name for the operation (optional). 

222 

223 Returns: 

224 A `Tensor`. Has the same type as `value`. 

225 """ 

226 _ctx = _context._context or _context.context() 

227 tld = _ctx._thread_local_data 

228 if tld.is_eager: 

229 try: 

230 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

231 _ctx, "AvgPool", name, value, "ksize", ksize, "strides", strides, 

232 "padding", padding, "data_format", data_format) 

233 return _result 

234 except _core._NotOkStatusException as e: 

235 _ops.raise_from_not_ok_status(e, name) 

236 except _core._FallbackException: 

237 pass 

238 try: 

239 return avg_pool_eager_fallback( 

240 value, ksize=ksize, strides=strides, padding=padding, 

241 data_format=data_format, name=name, ctx=_ctx) 

242 except _core._SymbolicException: 

243 pass # Add nodes to the TensorFlow graph. 

244 # Add nodes to the TensorFlow graph. 

245 if not isinstance(ksize, (list, tuple)): 

246 raise TypeError( 

247 "Expected list for 'ksize' argument to " 

248 "'avg_pool' Op, not %r." % ksize) 

249 ksize = [_execute.make_int(_i, "ksize") for _i in ksize] 

250 if not isinstance(strides, (list, tuple)): 

251 raise TypeError( 

252 "Expected list for 'strides' argument to " 

253 "'avg_pool' Op, not %r." % strides) 

254 strides = [_execute.make_int(_i, "strides") for _i in strides] 

255 padding = _execute.make_str(padding, "padding") 

256 if data_format is None: 

257 data_format = "NHWC" 

258 data_format = _execute.make_str(data_format, "data_format") 

259 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

260 "AvgPool", value=value, ksize=ksize, strides=strides, padding=padding, 

261 data_format=data_format, name=name) 

262 _result = _outputs[:] 

263 if _execute.must_record_gradient(): 

264 _attrs = ("ksize", _op.get_attr("ksize"), "strides", 

265 _op.get_attr("strides"), "padding", _op.get_attr("padding"), 

266 "data_format", _op.get_attr("data_format"), "T", 

267 _op._get_attr_type("T")) 

268 _inputs_flat = _op.inputs 

269 _execute.record_gradient( 

270 "AvgPool", _inputs_flat, _attrs, _result) 

271 _result, = _result 

272 return _result 

273 

274AvgPool = tf_export("raw_ops.AvgPool")(_ops.to_raw_op(avg_pool)) 

275 

276 

277def avg_pool_eager_fallback(value, ksize, strides, padding, data_format, name, ctx): 

278 if not isinstance(ksize, (list, tuple)): 

279 raise TypeError( 

280 "Expected list for 'ksize' argument to " 

281 "'avg_pool' Op, not %r." % ksize) 

282 ksize = [_execute.make_int(_i, "ksize") for _i in ksize] 

283 if not isinstance(strides, (list, tuple)): 

284 raise TypeError( 

285 "Expected list for 'strides' argument to " 

286 "'avg_pool' Op, not %r." % strides) 

287 strides = [_execute.make_int(_i, "strides") for _i in strides] 

288 padding = _execute.make_str(padding, "padding") 

289 if data_format is None: 

290 data_format = "NHWC" 

291 data_format = _execute.make_str(data_format, "data_format") 

292 _attr_T, (value,) = _execute.args_to_matching_eager([value], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ]) 

293 _inputs_flat = [value] 

294 _attrs = ("ksize", ksize, "strides", strides, "padding", padding, 

295 "data_format", data_format, "T", _attr_T) 

296 _result = _execute.execute(b"AvgPool", 1, inputs=_inputs_flat, attrs=_attrs, 

297 ctx=ctx, name=name) 

298 if _execute.must_record_gradient(): 

299 _execute.record_gradient( 

300 "AvgPool", _inputs_flat, _attrs, _result) 

301 _result, = _result 

302 return _result 

303 

304 

305def avg_pool3d(input, ksize, strides, padding, data_format="NDHWC", name=None): 

306 r"""Performs 3D average pooling on the input. 

307 

308 Each entry in `output` is the mean of the corresponding size `ksize` window in 

309 `value`. 

310 

311 Args: 

312 input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 

313 Shape `[batch, depth, rows, cols, channels]` tensor to pool over. 

314 ksize: A list of `ints` that has length `>= 5`. 

315 1-D tensor of length 5. The size of the window for each dimension of 

316 the input tensor. Must have `ksize[0] = ksize[4] = 1`. 

317 strides: A list of `ints` that has length `>= 5`. 

318 1-D tensor of length 5. The stride of the sliding window for each 

319 dimension of `input`. Must have `strides[0] = strides[4] = 1`. 

320 padding: A `string` from: `"SAME", "VALID"`. 

321 The type of padding algorithm to use. 

322 data_format: An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`. 

323 The data format of the input and output data. With the 

324 default format "NDHWC", the data is stored in the order of: 

325 [batch, in_depth, in_height, in_width, in_channels]. 

326 Alternatively, the format could be "NCDHW", the data storage order is: 

327 [batch, in_channels, in_depth, in_height, in_width]. 

328 name: A name for the operation (optional). 

329 

330 Returns: 

331 A `Tensor`. Has the same type as `input`. 

332 """ 

333 _ctx = _context._context or _context.context() 

334 tld = _ctx._thread_local_data 

335 if tld.is_eager: 

336 try: 

337 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

338 _ctx, "AvgPool3D", name, input, "ksize", ksize, "strides", strides, 

339 "padding", padding, "data_format", data_format) 

340 return _result 

341 except _core._NotOkStatusException as e: 

342 _ops.raise_from_not_ok_status(e, name) 

343 except _core._FallbackException: 

344 pass 

345 try: 

346 return avg_pool3d_eager_fallback( 

347 input, ksize=ksize, strides=strides, padding=padding, 

348 data_format=data_format, name=name, ctx=_ctx) 

349 except _core._SymbolicException: 

350 pass # Add nodes to the TensorFlow graph. 

351 # Add nodes to the TensorFlow graph. 

352 if not isinstance(ksize, (list, tuple)): 

353 raise TypeError( 

354 "Expected list for 'ksize' argument to " 

355 "'avg_pool3d' Op, not %r." % ksize) 

356 ksize = [_execute.make_int(_i, "ksize") for _i in ksize] 

357 if not isinstance(strides, (list, tuple)): 

358 raise TypeError( 

359 "Expected list for 'strides' argument to " 

360 "'avg_pool3d' Op, not %r." % strides) 

361 strides = [_execute.make_int(_i, "strides") for _i in strides] 

362 padding = _execute.make_str(padding, "padding") 

363 if data_format is None: 

364 data_format = "NDHWC" 

365 data_format = _execute.make_str(data_format, "data_format") 

366 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

367 "AvgPool3D", input=input, ksize=ksize, strides=strides, 

368 padding=padding, data_format=data_format, name=name) 

369 _result = _outputs[:] 

370 if _execute.must_record_gradient(): 

371 _attrs = ("ksize", _op.get_attr("ksize"), "strides", 

372 _op.get_attr("strides"), "padding", _op.get_attr("padding"), 

373 "data_format", _op.get_attr("data_format"), "T", 

374 _op._get_attr_type("T")) 

375 _inputs_flat = _op.inputs 

376 _execute.record_gradient( 

377 "AvgPool3D", _inputs_flat, _attrs, _result) 

378 _result, = _result 

379 return _result 

380 

381AvgPool3D = tf_export("raw_ops.AvgPool3D")(_ops.to_raw_op(avg_pool3d)) 

382 

383 

384def avg_pool3d_eager_fallback(input, ksize, strides, padding, data_format, name, ctx): 

385 if not isinstance(ksize, (list, tuple)): 

386 raise TypeError( 

387 "Expected list for 'ksize' argument to " 

388 "'avg_pool3d' Op, not %r." % ksize) 

389 ksize = [_execute.make_int(_i, "ksize") for _i in ksize] 

390 if not isinstance(strides, (list, tuple)): 

391 raise TypeError( 

392 "Expected list for 'strides' argument to " 

393 "'avg_pool3d' Op, not %r." % strides) 

394 strides = [_execute.make_int(_i, "strides") for _i in strides] 

395 padding = _execute.make_str(padding, "padding") 

396 if data_format is None: 

397 data_format = "NDHWC" 

398 data_format = _execute.make_str(data_format, "data_format") 

399 _attr_T, (input,) = _execute.args_to_matching_eager([input], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ]) 

400 _inputs_flat = [input] 

401 _attrs = ("ksize", ksize, "strides", strides, "padding", padding, 

402 "data_format", data_format, "T", _attr_T) 

403 _result = _execute.execute(b"AvgPool3D", 1, inputs=_inputs_flat, 

404 attrs=_attrs, ctx=ctx, name=name) 

405 if _execute.must_record_gradient(): 

406 _execute.record_gradient( 

407 "AvgPool3D", _inputs_flat, _attrs, _result) 

408 _result, = _result 

409 return _result 

410 

411 

412def avg_pool3d_grad(orig_input_shape, grad, ksize, strides, padding, data_format="NDHWC", name=None): 

413 r"""Computes gradients of average pooling function. 

414 

415 Args: 

416 orig_input_shape: A `Tensor` of type `int32`. 

417 The original input dimensions. 

418 grad: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 

419 Output backprop of shape `[batch, depth, rows, cols, channels]`. 

420 ksize: A list of `ints` that has length `>= 5`. 

421 1-D tensor of length 5. The size of the window for each dimension of 

422 the input tensor. Must have `ksize[0] = ksize[4] = 1`. 

423 strides: A list of `ints` that has length `>= 5`. 

424 1-D tensor of length 5. The stride of the sliding window for each 

425 dimension of `input`. Must have `strides[0] = strides[4] = 1`. 

426 padding: A `string` from: `"SAME", "VALID"`. 

427 The type of padding algorithm to use. 

428 data_format: An optional `string` from: `"NDHWC", "NCDHW"`. Defaults to `"NDHWC"`. 

429 The data format of the input and output data. With the 

430 default format "NDHWC", the data is stored in the order of: 

431 [batch, in_depth, in_height, in_width, in_channels]. 

432 Alternatively, the format could be "NCDHW", the data storage order is: 

433 [batch, in_channels, in_depth, in_height, in_width]. 

434 name: A name for the operation (optional). 

435 

436 Returns: 

437 A `Tensor`. Has the same type as `grad`. 

438 """ 

439 _ctx = _context._context or _context.context() 

440 tld = _ctx._thread_local_data 

441 if tld.is_eager: 

442 try: 

443 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

444 _ctx, "AvgPool3DGrad", name, orig_input_shape, grad, "ksize", ksize, 

445 "strides", strides, "padding", padding, "data_format", data_format) 

446 return _result 

447 except _core._NotOkStatusException as e: 

448 _ops.raise_from_not_ok_status(e, name) 

449 except _core._FallbackException: 

450 pass 

451 try: 

452 return avg_pool3d_grad_eager_fallback( 

453 orig_input_shape, grad, ksize=ksize, strides=strides, 

454 padding=padding, data_format=data_format, name=name, ctx=_ctx) 

455 except _core._SymbolicException: 

456 pass # Add nodes to the TensorFlow graph. 

457 # Add nodes to the TensorFlow graph. 

458 if not isinstance(ksize, (list, tuple)): 

459 raise TypeError( 

460 "Expected list for 'ksize' argument to " 

461 "'avg_pool3d_grad' Op, not %r." % ksize) 

462 ksize = [_execute.make_int(_i, "ksize") for _i in ksize] 

463 if not isinstance(strides, (list, tuple)): 

464 raise TypeError( 

465 "Expected list for 'strides' argument to " 

466 "'avg_pool3d_grad' Op, not %r." % strides) 

467 strides = [_execute.make_int(_i, "strides") for _i in strides] 

468 padding = _execute.make_str(padding, "padding") 

469 if data_format is None: 

470 data_format = "NDHWC" 

471 data_format = _execute.make_str(data_format, "data_format") 

472 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

473 "AvgPool3DGrad", orig_input_shape=orig_input_shape, grad=grad, 

474 ksize=ksize, strides=strides, padding=padding, 

475 data_format=data_format, name=name) 

476 _result = _outputs[:] 

477 if _execute.must_record_gradient(): 

478 _attrs = ("ksize", _op.get_attr("ksize"), "strides", 

479 _op.get_attr("strides"), "padding", _op.get_attr("padding"), 

480 "data_format", _op.get_attr("data_format"), "T", 

481 _op._get_attr_type("T")) 

482 _inputs_flat = _op.inputs 

483 _execute.record_gradient( 

484 "AvgPool3DGrad", _inputs_flat, _attrs, _result) 

485 _result, = _result 

486 return _result 

487 

488AvgPool3DGrad = tf_export("raw_ops.AvgPool3DGrad")(_ops.to_raw_op(avg_pool3d_grad)) 

489 

490 

491def avg_pool3d_grad_eager_fallback(orig_input_shape, grad, ksize, strides, padding, data_format, name, ctx): 

492 if not isinstance(ksize, (list, tuple)): 

493 raise TypeError( 

494 "Expected list for 'ksize' argument to " 

495 "'avg_pool3d_grad' Op, not %r." % ksize) 

496 ksize = [_execute.make_int(_i, "ksize") for _i in ksize] 

497 if not isinstance(strides, (list, tuple)): 

498 raise TypeError( 

499 "Expected list for 'strides' argument to " 

500 "'avg_pool3d_grad' Op, not %r." % strides) 

501 strides = [_execute.make_int(_i, "strides") for _i in strides] 

502 padding = _execute.make_str(padding, "padding") 

503 if data_format is None: 

504 data_format = "NDHWC" 

505 data_format = _execute.make_str(data_format, "data_format") 

506 _attr_T, (grad,) = _execute.args_to_matching_eager([grad], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ]) 

507 orig_input_shape = _ops.convert_to_tensor(orig_input_shape, _dtypes.int32) 

508 _inputs_flat = [orig_input_shape, grad] 

509 _attrs = ("ksize", ksize, "strides", strides, "padding", padding, 

510 "data_format", data_format, "T", _attr_T) 

511 _result = _execute.execute(b"AvgPool3DGrad", 1, inputs=_inputs_flat, 

512 attrs=_attrs, ctx=ctx, name=name) 

513 if _execute.must_record_gradient(): 

514 _execute.record_gradient( 

515 "AvgPool3DGrad", _inputs_flat, _attrs, _result) 

516 _result, = _result 

517 return _result 

518 

519 

520def avg_pool_grad(orig_input_shape, grad, ksize, strides, padding, data_format="NHWC", name=None): 

521 r"""Computes gradients of the average pooling function. 

522 

523 Args: 

524 orig_input_shape: A `Tensor` of type `int32`. 

525 1-D. Shape of the original input to `avg_pool`. 

526 grad: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`. 

527 4-D with shape `[batch, height, width, channels]`. Gradients w.r.t. 

528 the output of `avg_pool`. 

529 ksize: A list of `ints` that has length `>= 4`. 

530 The size of the sliding window for each dimension of the input. 

531 strides: A list of `ints` that has length `>= 4`. 

532 The stride of the sliding window for each dimension of the input. 

533 padding: A `string` from: `"SAME", "VALID"`. 

534 The type of padding algorithm to use. 

535 data_format: An optional `string` from: `"NHWC", "NCHW"`. Defaults to `"NHWC"`. 

536 Specify the data format of the input and output data. With the 

537 default format "NHWC", the data is stored in the order of: 

538 [batch, in_height, in_width, in_channels]. 

539 Alternatively, the format could be "NCHW", the data storage order of: 

540 [batch, in_channels, in_height, in_width]. 

541 name: A name for the operation (optional). 

542 

543 Returns: 

544 A `Tensor`. Has the same type as `grad`. 

545 """ 

546 _ctx = _context._context or _context.context() 

547 tld = _ctx._thread_local_data 

548 if tld.is_eager: 

549 try: 

550 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

551 _ctx, "AvgPoolGrad", name, orig_input_shape, grad, "ksize", ksize, 

552 "strides", strides, "padding", padding, "data_format", data_format) 

553 return _result 

554 except _core._NotOkStatusException as e: 

555 _ops.raise_from_not_ok_status(e, name) 

556 except _core._FallbackException: 

557 pass 

558 try: 

559 return avg_pool_grad_eager_fallback( 

560 orig_input_shape, grad, ksize=ksize, strides=strides, 

561 padding=padding, data_format=data_format, name=name, ctx=_ctx) 

562 except _core._SymbolicException: 

563 pass # Add nodes to the TensorFlow graph. 

564 # Add nodes to the TensorFlow graph. 

565 if not isinstance(ksize, (list, tuple)): 

566 raise TypeError( 

567 "Expected list for 'ksize' argument to " 

568 "'avg_pool_grad' Op, not %r." % ksize) 

569 ksize = [_execute.make_int(_i, "ksize") for _i in ksize] 

570 if not isinstance(strides, (list, tuple)): 

571 raise TypeError( 

572 "Expected list for 'strides' argument to " 

573 "'avg_pool_grad' Op, not %r." % strides) 

574 strides = [_execute.make_int(_i, "strides") for _i in strides] 

575 padding = _execute.make_str(padding, "padding") 

576 if data_format is None: 

577 data_format = "NHWC" 

578 data_format = _execute.make_str(data_format, "data_format") 

579 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

580 "AvgPoolGrad", orig_input_shape=orig_input_shape, grad=grad, 

581 ksize=ksize, strides=strides, padding=padding, 

582 data_format=data_format, name=name) 

583 _result = _outputs[:] 

584 if _execute.must_record_gradient(): 

585 _attrs = ("ksize", _op.get_attr("ksize"), "strides", 

586 _op.get_attr("strides"), "padding", _op.get_attr("padding"), 

587 "data_format", _op.get_attr("data_format"), "T", 

588 _op._get_attr_type("T")) 

589 _inputs_flat = _op.inputs 

590 _execute.record_gradient( 

591 "AvgPoolGrad", _inputs_flat, _attrs, _result) 

592 _result, = _result 

593 return _result 

594 

595AvgPoolGrad = tf_export("raw_ops.AvgPoolGrad")(_ops.to_raw_op(avg_pool_grad)) 

596 

597 

598def avg_pool_grad_eager_fallback(orig_input_shape, grad, ksize, strides, padding, data_format, name, ctx): 

599 if not isinstance(ksize, (list, tuple)): 

600 raise TypeError( 

601 "Expected list for 'ksize' argument to " 

602 "'avg_pool_grad' Op, not %r." % ksize) 

603 ksize = [_execute.make_int(_i, "ksize") for _i in ksize] 

604 if not isinstance(strides, (list, tuple)): 

605 raise TypeError( 

606 "Expected list for 'strides' argument to " 

607 "'avg_pool_grad' Op, not %r." % strides) 

608 strides = [_execute.make_int(_i, "strides") for _i in strides] 

609 padding = _execute.make_str(padding, "padding") 

610 if data_format is None: 

611 data_format = "NHWC" 

612 data_format = _execute.make_str(data_format, "data_format") 

613 _attr_T, (grad,) = _execute.args_to_matching_eager([grad], ctx, [_dtypes.half, _dtypes.bfloat16, _dtypes.float32, _dtypes.float64, ]) 

614 orig_input_shape = _ops.convert_to_tensor(orig_input_shape, _dtypes.int32) 

615 _inputs_flat = [orig_input_shape, grad] 

616 _attrs = ("ksize", ksize, "strides", strides, "padding", padding, 

617 "data_format", data_format, "T", _attr_T) 

618 _result = _execute.execute(b"AvgPoolGrad", 1, inputs=_inputs_flat, 

619 attrs=_attrs, ctx=ctx, name=name) 

620 if _execute.must_record_gradient(): 

621 _execute.record_gradient( 

622 "AvgPoolGrad", _inputs_flat, _attrs, _result) 

623 _result, = _result 

624 return _result 

625 

626 

627def _batch_norm_with_global_normalization(t, m, v, beta, gamma, variance_epsilon, scale_after_normalization, name=None): 

628 r"""Batch normalization. 

629 

630 This op is deprecated. Prefer `tf.nn.batch_normalization`. 

631 

632 Args: 

633 t: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. 

634 A 4D input Tensor. 

635 m: A `Tensor`. Must have the same type as `t`. 

636 A 1D mean Tensor with size matching the last dimension of t. 

637 This is the first output from tf.nn.moments, 

638 or a saved moving average thereof. 

639 v: A `Tensor`. Must have the same type as `t`. 

640 A 1D variance Tensor with size matching the last dimension of t. 

641 This is the second output from tf.nn.moments, 

642 or a saved moving average thereof. 

643 beta: A `Tensor`. Must have the same type as `t`. 

644 A 1D beta Tensor with size matching the last dimension of t. 

645 An offset to be added to the normalized tensor. 

646 gamma: A `Tensor`. Must have the same type as `t`. 

647 A 1D gamma Tensor with size matching the last dimension of t. 

648 If "scale_after_normalization" is true, this tensor will be multiplied 

649 with the normalized tensor. 

650 variance_epsilon: A `float`. A small float number to avoid dividing by 0. 

651 scale_after_normalization: A `bool`. 

652 A bool indicating whether the resulted tensor 

653 needs to be multiplied with gamma. 

654 name: A name for the operation (optional). 

655 

656 Returns: 

657 A `Tensor`. Has the same type as `t`. 

658 """ 

659 _ctx = _context._context or _context.context() 

660 tld = _ctx._thread_local_data 

661 if tld.is_eager: 

662 try: 

663 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

664 _ctx, "BatchNormWithGlobalNormalization", name, t, m, v, beta, gamma, 

665 "variance_epsilon", variance_epsilon, "scale_after_normalization", 

666 scale_after_normalization) 

667 return _result 

668 except _core._NotOkStatusException as e: 

669 _ops.raise_from_not_ok_status(e, name) 

670 except _core._FallbackException: 

671 pass 

672 try: 

673 return _batch_norm_with_global_normalization_eager_fallback( 

674 t, m, v, beta, gamma, variance_epsilon=variance_epsilon, 

675 scale_after_normalization=scale_after_normalization, name=name, 

676 ctx=_ctx) 

677 except _core._SymbolicException: 

678 pass # Add nodes to the TensorFlow graph. 

679 # Add nodes to the TensorFlow graph. 

680 variance_epsilon = _execute.make_float(variance_epsilon, "variance_epsilon") 

681 scale_after_normalization = _execute.make_bool(scale_after_normalization, "scale_after_normalization") 

682 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

683 "BatchNormWithGlobalNormalization", t=t, m=m, v=v, beta=beta, 

684 gamma=gamma, 

685 variance_epsilon=variance_epsilon, 

686 scale_after_normalization=scale_after_normalization, 

687 name=name) 

688 _result = _outputs[:] 

689 if _execute.must_record_gradient(): 

690 _attrs = ("T", _op._get_attr_type("T"), "variance_epsilon", 

691 _op.get_attr("variance_epsilon"), "scale_after_normalization", 

692 _op._get_attr_bool("scale_after_normalization")) 

693 _inputs_flat = _op.inputs 

694 _execute.record_gradient( 

695 "BatchNormWithGlobalNormalization", _inputs_flat, _attrs, _result) 

696 _result, = _result 

697 return _result 

698 

699BatchNormWithGlobalNormalization = tf_export("raw_ops.BatchNormWithGlobalNormalization")(_ops.to_raw_op(_batch_norm_with_global_normalization)) 

700 

701 

702def _batch_norm_with_global_normalization_eager_fallback(t, m, v, beta, gamma, variance_epsilon, scale_after_normalization, name, ctx): 

703 variance_epsilon = _execute.make_float(variance_epsilon, "variance_epsilon") 

704 scale_after_normalization = _execute.make_bool(scale_after_normalization, "scale_after_normalization") 

705 _attr_T, _inputs_T = _execute.args_to_matching_eager([t, m, v, beta, gamma], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.complex64, _dtypes.int64, _dtypes.qint8, _dtypes.quint8, _dtypes.qint32, _dtypes.bfloat16, _dtypes.qint16, _dtypes.quint16, _dtypes.uint16, _dtypes.complex128, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ]) 

706 (t, m, v, beta, gamma) = _inputs_T 

707 _inputs_flat = [t, m, v, beta, gamma] 

708 _attrs = ("T", _attr_T, "variance_epsilon", variance_epsilon, 

709 "scale_after_normalization", scale_after_normalization) 

710 _result = _execute.execute(b"BatchNormWithGlobalNormalization", 1, 

711 inputs=_inputs_flat, attrs=_attrs, ctx=ctx, 

712 name=name) 

713 if _execute.must_record_gradient(): 

714 _execute.record_gradient( 

715 "BatchNormWithGlobalNormalization", _inputs_flat, _attrs, _result) 

716 _result, = _result 

717 return _result 

718 

719_BatchNormWithGlobalNormalizationGradOutput = collections.namedtuple( 

720 "BatchNormWithGlobalNormalizationGrad", 

721 ["dx", "dm", "dv", "db", "dg"]) 

722 

723 

724def batch_norm_with_global_normalization_grad(t, m, v, gamma, backprop, variance_epsilon, scale_after_normalization, name=None): 

725 r"""Gradients for batch normalization. 

726 

727 This op is deprecated. See `tf.nn.batch_normalization`. 

728 

729 Args: 

730 t: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. 

731 A 4D input Tensor. 

732 m: A `Tensor`. Must have the same type as `t`. 

733 A 1D mean Tensor with size matching the last dimension of t. 

734 This is the first output from tf.nn.moments, 

735 or a saved moving average thereof. 

736 v: A `Tensor`. Must have the same type as `t`. 

737 A 1D variance Tensor with size matching the last dimension of t. 

738 This is the second output from tf.nn.moments, 

739 or a saved moving average thereof. 

740 gamma: A `Tensor`. Must have the same type as `t`. 

741 A 1D gamma Tensor with size matching the last dimension of t. 

742 If "scale_after_normalization" is true, this Tensor will be multiplied 

743 with the normalized Tensor. 

744 backprop: A `Tensor`. Must have the same type as `t`. 4D backprop Tensor. 

745 variance_epsilon: A `float`. A small float number to avoid dividing by 0. 

746 scale_after_normalization: A `bool`. 

747 A bool indicating whether the resulted tensor