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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
/**
 * @license
 * Copyright 2018 Google LLC
 *
 * Use of this source code is governed by an MIT-style
 * license that can be found in the LICENSE file or at
 * https://opensource.org/licenses/MIT.
 * =============================================================================
 */
/**
 * TensorFlow.js Layers: Noise Layers.
 */
import { add, greaterEqual, mul, randomUniform, serialization, tidy } from '@tensorflow/tfjs-core';
import * as K from '../backend/tfjs_backend';
import { Layer } from '../engine/topology';
import { getExactlyOneTensor } from '../utils/types_utils';
class GaussianNoise extends Layer {
    constructor(args) {
        super(args);
        this.supportsMasking = true;
        this.stddev = args.stddev;
    }
    computeOutputShape(inputShape) {
        return inputShape;
    }
    getConfig() {
        const baseConfig = super.getConfig();
        const config = { stddev: this.stddev };
        Object.assign(config, baseConfig);
        return config;
    }
    call(inputs, kwargs) {
        return tidy(() => {
            this.invokeCallHook(inputs, kwargs);
            const input = getExactlyOneTensor(inputs);
            const noised = () => add(K.randomNormal(input.shape, 0, this.stddev), input);
            const output = K.inTrainPhase(noised, () => input, kwargs['training'] || false);
            return output;
        });
    }
}
/** @nocollapse */
GaussianNoise.className = 'GaussianNoise';
export { GaussianNoise };
serialization.registerClass(GaussianNoise);
class GaussianDropout extends Layer {
    constructor(args) {
        super(args);
        this.supportsMasking = true;
        this.rate = args.rate;
    }
    computeOutputShape(inputShape) {
        return inputShape;
    }
    getConfig() {
        const baseConfig = super.getConfig();
        const config = { rate: this.rate };
        Object.assign(config, baseConfig);
        return config;
    }
    call(inputs, kwargs) {
        return tidy(() => {
            this.invokeCallHook(inputs, kwargs);
            const input = getExactlyOneTensor(inputs);
            if (this.rate > 0 && this.rate < 1) {
                const noised = () => {
                    const stddev = Math.sqrt(this.rate / (1 - this.rate));
                    return mul(input, K.randomNormal(input.shape, 1, stddev));
                };
                return K.inTrainPhase(noised, () => input, kwargs['training'] || false);
            }
            return input;
        });
    }
}
/** @nocollapse */
GaussianDropout.className = 'GaussianDropout';
export { GaussianDropout };
serialization.registerClass(GaussianDropout);
/**
 * Applies Alpha Dropout to the input.
 *
 * As it is a regularization layer, it is only active at training time.
 *
 * Alpha Dropout is a `Dropout` that keeps mean and variance of inputs
 * to their original values, in order to ensure the self-normalizing property
 * even after this dropout.
 * Alpha Dropout fits well to Scaled Exponential Linear Units
 * by randomly setting activations to the negative saturation value.
 *
 * Arguments:
 *   - `rate`: float, drop probability (as with `Dropout`).
 *     The multiplicative noise will have
 *     standard deviation `sqrt(rate / (1 - rate))`.
 *   - `noise_shape`: A 1-D `Tensor` of type `int32`, representing the
 *     shape for randomly generated keep/drop flags.
 *
 * Input shape:
 *   Arbitrary. Use the keyword argument `inputShape`
 *   (tuple of integers, does not include the samples axis)
 *   when using this layer as the first layer in a model.
 *
 * Output shape:
 *   Same shape as input.
 *
 * References:
 *   - [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)
 */
class AlphaDropout extends Layer {
    constructor(args) {
        super(args);
        this.supportsMasking = true;
        this.rate = args.rate;
        this.noiseShape = args.noiseShape;
    }
    _getNoiseShape(inputs) {
        return this.noiseShape || getExactlyOneTensor(inputs).shape;
    }
    computeOutputShape(inputShape) {
        return inputShape;
    }
    getConfig() {
        const baseConfig = super.getConfig();
        const config = { rate: this.rate };
        Object.assign(config, baseConfig);
        return config;
    }
    call(inputs, kwargs) {
        return tidy(() => {
            if (this.rate < 1 && this.rate > 0) {
                const noiseShape = this._getNoiseShape(inputs);
                const droppedInputs = () => {
                    const input = getExactlyOneTensor(inputs);
                    const alpha = 1.6732632423543772848170429916717;
                    const scale = 1.0507009873554804934193349852946;
                    const alphaP = -alpha * scale;
                    let keptIdx = greaterEqual(randomUniform(noiseShape), this.rate);
                    keptIdx = K.cast(keptIdx, 'float32'); // get default dtype.
                    // Get affine transformation params.
                    const a = ((1 - this.rate) * (1 + this.rate * alphaP ** 2)) ** -0.5;
                    const b = -a * alphaP * this.rate;
                    // Apply mask.
                    const x = add(mul(input, keptIdx), mul(add(keptIdx, -1), alphaP));
                    return add(mul(x, a), b);
                };
                return K.inTrainPhase(droppedInputs, () => getExactlyOneTensor(inputs), kwargs['training'] || false);
            }
            return inputs;
        });
    }
}
/** @nocollapse */
AlphaDropout.className = 'AlphaDropout';
export { AlphaDropout };
serialization.registerClass(AlphaDropout);
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"noise.js","sourceRoot":"","sources":["../../../../../../tfjs-layers/src/layers/noise.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC\n *\n * Use of this source code is governed by an MIT-style\n * license that can be found in the LICENSE file or at\n * https://opensource.org/licenses/MIT.\n * =============================================================================\n */\n\n/**\n * TensorFlow.js Layers: Noise Layers.\n */\n\nimport {add, greaterEqual, mul, randomUniform, serialization, Tensor, tidy} from '@tensorflow/tfjs-core';\n\nimport * as K from '../backend/tfjs_backend';\nimport {Layer, LayerArgs} from '../engine/topology';\nimport {Shape} from '../keras_format/common';\nimport {Kwargs} from '../types';\nimport {getExactlyOneTensor} from '../utils/types_utils';\n\nexport declare interface GaussianNoiseArgs extends LayerArgs {\n  /** Standard Deviation.  */\n  stddev: number;\n}\n\nexport class GaussianNoise extends Layer {\n  /** @nocollapse */\n  static className = 'GaussianNoise';\n  readonly stddev: number;\n\n  constructor(args: GaussianNoiseArgs) {\n    super(args);\n    this.supportsMasking = true;\n    this.stddev = args.stddev;\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    return inputShape;\n  }\n\n  override getConfig() {\n    const baseConfig = super.getConfig();\n    const config = {stddev: this.stddev};\n    Object.assign(config, baseConfig);\n    return config;\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    return tidy(() => {\n      this.invokeCallHook(inputs, kwargs);\n      const input = getExactlyOneTensor(inputs);\n      const noised = () =>\n          add(K.randomNormal(input.shape, 0, this.stddev), input);\n      const output =\n          K.inTrainPhase(noised, () => input, kwargs['training'] || false);\n      return output;\n    });\n  }\n}\nserialization.registerClass(GaussianNoise);\n\nexport declare interface GaussianDropoutArgs extends LayerArgs {\n  /** drop probability.  */\n  rate: number;\n}\n\nexport class GaussianDropout extends Layer {\n  /** @nocollapse */\n  static className = 'GaussianDropout';\n  readonly rate: number;\n\n  constructor(args: GaussianDropoutArgs) {\n    super(args);\n    this.supportsMasking = true;\n    this.rate = args.rate;\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    return inputShape;\n  }\n\n  override getConfig() {\n    const baseConfig = super.getConfig();\n    const config = {rate: this.rate};\n    Object.assign(config, baseConfig);\n    return config;\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    return tidy(() => {\n      this.invokeCallHook(inputs, kwargs);\n      const input = getExactlyOneTensor(inputs);\n      if (this.rate > 0 && this.rate < 1) {\n        const noised = () => {\n          const stddev = Math.sqrt(this.rate / (1 - this.rate));\n          return mul(input, K.randomNormal(input.shape, 1, stddev));\n        };\n        return K.inTrainPhase(noised, () => input, kwargs['training'] || false);\n      }\n      return input;\n    });\n  }\n}\nserialization.registerClass(GaussianDropout);\n\nexport declare interface AlphaDropoutArgs extends LayerArgs {\n  /** drop probability.  */\n  rate: number;\n  /**\n   * A 1-D `Tensor` of type `int32`, representing the\n   * shape for randomly generated keep/drop flags.\n   */\n  noiseShape?: Shape;\n}\n\n/**\n * Applies Alpha Dropout to the input.\n *\n * As it is a regularization layer, it is only active at training time.\n *\n * Alpha Dropout is a `Dropout` that keeps mean and variance of inputs\n * to their original values, in order to ensure the self-normalizing property\n * even after this dropout.\n * Alpha Dropout fits well to Scaled Exponential Linear Units\n * by randomly setting activations to the negative saturation value.\n *\n * Arguments:\n *   - `rate`: float, drop probability (as with `Dropout`).\n *     The multiplicative noise will have\n *     standard deviation `sqrt(rate / (1 - rate))`.\n *   - `noise_shape`: A 1-D `Tensor` of type `int32`, representing the\n *     shape for randomly generated keep/drop flags.\n *\n * Input shape:\n *   Arbitrary. Use the keyword argument `inputShape`\n *   (tuple of integers, does not include the samples axis)\n *   when using this layer as the first layer in a model.\n *\n * Output shape:\n *   Same shape as input.\n *\n * References:\n *   - [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)\n */\nexport class AlphaDropout extends Layer {\n  /** @nocollapse */\n  static className = 'AlphaDropout';\n  readonly rate: number;\n  readonly noiseShape: Shape;\n\n  constructor(args: AlphaDropoutArgs) {\n    super(args);\n    this.supportsMasking = true;\n    this.rate = args.rate;\n    this.noiseShape = args.noiseShape;\n  }\n\n  _getNoiseShape(inputs: Tensor|Tensor[]) {\n    return this.noiseShape || getExactlyOneTensor(inputs).shape;\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    return inputShape;\n  }\n\n  override getConfig() {\n    const baseConfig = super.getConfig();\n    const config = {rate: this.rate};\n    Object.assign(config, baseConfig);\n    return config;\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    return tidy(() => {\n      if (this.rate < 1 && this.rate > 0) {\n        const noiseShape = this._getNoiseShape(inputs);\n\n        const droppedInputs = () => {\n          const input = getExactlyOneTensor(inputs);\n\n          const alpha = 1.6732632423543772848170429916717;\n          const scale = 1.0507009873554804934193349852946;\n\n          const alphaP = -alpha * scale;\n\n          let keptIdx = greaterEqual(randomUniform(noiseShape), this.rate);\n\n          keptIdx = K.cast(keptIdx, 'float32');  // get default dtype.\n\n          // Get affine transformation params.\n          const a = ((1 - this.rate) * (1 + this.rate * alphaP ** 2)) ** -0.5;\n          const b = -a * alphaP * this.rate;\n\n          // Apply mask.\n          const x = add(mul(input, keptIdx), mul(add(keptIdx, -1), alphaP));\n\n          return add(mul(x, a), b);\n        };\n        return K.inTrainPhase(\n            droppedInputs, () => getExactlyOneTensor(inputs),\n            kwargs['training'] || false);\n      }\n      return inputs;\n    });\n  }\n}\nserialization.registerClass(AlphaDropout);\n"]}