gx

chenyc

2025-02-12 ea42ff3ebee1eeb3fb29423aa848a249441db81c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/**
 * @license
 * Copyright 2022 Google Inc. 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.
 * =============================================================================
 */
import { backend_util } from '../base';
import { Prod } from '../kernel_names';
import { cumprod } from '../ops/cumprod';
import { mul } from '../ops/mul';
import { reshape } from '../ops/reshape';
import { transpose } from '../ops/transpose';
// Gradient for product operation on a single axis.
function prodGradFn_(x, dy, axis) {
    // The gradient tensor (dy) has a set of axes removed, so we create re-shaped
    // versions (of size 1) for the removed axis; this supports broadcasting over
    // those dimensions.
    const expandedYShape = x.shape.slice();
    expandedYShape[axis] = 1;
    // The actual gradient computation.
    const expandedDy = reshape(dy, expandedYShape);
    const xCumProd = cumprod(x, axis, true, false);
    const xCumRevProd = cumprod(x, axis, true, true);
    const dx = mul(xCumProd, xCumRevProd);
    return mul(expandedDy, dx);
}
// Support gradients when the product is done on many axes at once.
// This done py pushing all the axes on which the product is applied into a
// single axis.
function prodsGradFn_(x, dy, axis) {
    // Move all axes for doing prod over to the end of the tensor.
    const xRank = x.shape.length;
    const finalProdAxis = xRank - axis.length;
    const xPermutation = backend_util.getAxesPermutation(axis, xRank);
    let permutedX = x;
    if (xPermutation != null) {
        permutedX = transpose(x, xPermutation);
    }
    // Reshape all the prod dimensions into a single one, and do compute prod
    // gradients on that.
    const newShape = permutedX.shape.slice();
    const removedShape = newShape.splice(xRank - axis.length, axis.length);
    const endPartShape = removedShape.reduce((p, c) => p * c, 1);
    newShape.push(endPartShape);
    const reshapedPermutedX = permutedX.reshape(newShape);
    let prodGrad = prodGradFn_(reshapedPermutedX, dy, finalProdAxis);
    // Undo the re-shaping now we have the dx vector, and permute back to
    // original axes order.
    prodGrad = prodGrad.reshape(permutedX.shape);
    if (xPermutation != null) {
        const undoPermutation = backend_util.getUndoAxesPermutation(xPermutation);
        prodGrad = transpose(prodGrad, undoPermutation);
    }
    return prodGrad;
}
// Running example:
// [
//   [
//     [3.0, 4.0],
//     [5.0, 6.0],
//     [7.0, 8.0]
//   ],
//   [
//     [3.0, 5.0],
//     [0.0, 6.0],
//     [5.0, 6.0]
//   ]
// ]
//
export const prodGradConfig = {
    kernelName: Prod,
    inputsToSave: ['x'],
    gradFunc: (dy, saved, attrs) => {
        const [x] = saved;
        const { axis } = attrs;
        let axisArr = [];
        if (axis === undefined || axis === null) {
            axisArr = x.shape.map((_, i) => i);
        }
        else if (typeof axis === 'number') {
            axisArr = [axis];
        }
        else {
            axisArr = axis;
        }
        return { x: () => prodsGradFn_(x, dy, axisArr) };
    }
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Prod_grad.js","sourceRoot":"","sources":["../../../../../../tfjs-core/src/gradients/Prod_grad.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2022 Google Inc. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\nimport {backend_util} from '../base';\nimport {Prod, ProdAttrs} from '../kernel_names';\nimport {GradConfig, NamedAttrMap} from '../kernel_registry';\nimport {cumprod} from '../ops/cumprod';\nimport {mul} from '../ops/mul';\nimport {reshape} from '../ops/reshape';\nimport {transpose} from '../ops/transpose';\nimport {Tensor} from '../tensor';\n\n// Gradient for product operation on a single axis.\nfunction prodGradFn_(x: Tensor, dy: Tensor, axis: number): Tensor {\n  // The gradient tensor (dy) has a set of axes removed, so we create re-shaped\n  // versions (of size 1) for the removed axis; this supports broadcasting over\n  // those dimensions.\n  const expandedYShape = x.shape.slice();\n  expandedYShape[axis] = 1;\n\n  // The actual gradient computation.\n  const expandedDy = reshape(dy, expandedYShape);\n  const xCumProd = cumprod(x, axis, true, false);\n  const xCumRevProd = cumprod(x, axis, true, true);\n  const dx = mul(xCumProd, xCumRevProd);\n  return mul(expandedDy, dx);\n}\n\n// Support gradients when the product is done on many axes at once.\n// This done py pushing all the axes on which the product is applied into a\n// single axis.\nfunction prodsGradFn_(x: Tensor, dy: Tensor, axis: number[]): Tensor {\n  // Move all axes for doing prod over to the end of the tensor.\n  const xRank = x.shape.length;\n  const finalProdAxis = xRank - axis.length;\n  const xPermutation = backend_util.getAxesPermutation(axis, xRank);\n  let permutedX = x;\n  if (xPermutation != null) {\n    permutedX = transpose(x, xPermutation);\n  }\n\n  // Reshape all the prod dimensions into a single one, and do compute prod\n  // gradients on that.\n  const newShape = permutedX.shape.slice();\n  const removedShape = newShape.splice(xRank - axis.length, axis.length);\n  const endPartShape = removedShape.reduce((p, c) => p * c, 1);\n  newShape.push(endPartShape);\n  const reshapedPermutedX = permutedX.reshape(newShape);\n  let prodGrad = prodGradFn_(reshapedPermutedX, dy, finalProdAxis);\n\n  // Undo the re-shaping now we have the dx vector, and permute back to\n  // original axes order.\n  prodGrad = prodGrad.reshape(permutedX.shape);\n  if (xPermutation != null) {\n    const undoPermutation = backend_util.getUndoAxesPermutation(xPermutation);\n    prodGrad = transpose(prodGrad, undoPermutation);\n  }\n  return prodGrad;\n}\n\n// Running example:\n// [\n//   [\n//     [3.0, 4.0],\n//     [5.0, 6.0],\n//     [7.0, 8.0]\n//   ],\n//   [\n//     [3.0, 5.0],\n//     [0.0, 6.0],\n//     [5.0, 6.0]\n//   ]\n// ]\n//\nexport const prodGradConfig: GradConfig = {\n  kernelName: Prod,\n  inputsToSave: ['x'],\n  gradFunc: (dy: Tensor|Tensor[], saved: Tensor[], attrs: NamedAttrMap) => {\n    const [x] = saved;\n    const {axis} = (attrs as {}) as ProdAttrs;\n    let axisArr = [] as number[];\n    if (axis === undefined || axis === null) {\n      axisArr = x.shape.map((_, i) => i);\n    } else if (typeof axis === 'number') {\n      axisArr = [axis];\n    } else {\n      axisArr = axis;\n    }\n    return {x: () => prodsGradFn_(x, dy as Tensor, axisArr)};\n  }\n};\n"]}