4578689396

Build Type

github

Committed by GitHub

Commit Message

Merge ddb425c30 into 6a993cb7a

Pull Request Pull Request #436: Model training overhaul: SNGP model, uncertainty visualization, and custom embedding support

Run Details

462 of 1163 branches covered (39.72%)

Branch coverage included in aggregate %.

20 of 628 new or added lines in 27 files covered. (3.18%)

76 existing lines in 5 files now uncovered.

3248 of 5431 relevant lines covered (59.8%)

543.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

1.22

/frontend/src/Project/service/labels/tensorflow/gaussianProcessLayer.ts

// Adapted from https://github.com/tensorflow/models/blob/master/official/nlp/modeling/layers/gaussian_process.py

import * as tf from '@tensorflow/tfjs';
import { LayerVariable, Shape, Tensor } from '@tensorflow/tfjs';
import { serialization } from '@tensorflow/tfjs-core';
import { Initializer, Zeros } from '@tensorflow/tfjs-layers/dist/initializers';
import { Dense } from '@tensorflow/tfjs-layers/dist/layers/core';
import { Cos } from './cos';
import { LaplaceRandomFeatureCovariance } from './laplaceRandomFeatureCovariance';
import { Kwargs } from './spectralNormalizationLayer';
import { diagPart } from './tfcUtils';

export class RandomFeatureGaussianProcess extends tf.layers.Layer {
  units: number;
  numInducing: number;
  gpKernelType: string;
  gpKernelScale: number;
  gpOutputBias: number;
  normalizeInput: boolean;
  gpInputScale: number;
  gpFeatureScale: number;
  gpKernelScaleTrainable: boolean;
  gpOutputBiasTrainable: boolean;
  gpCovMomentum: number;
  gpCovRidgePenalty: number;
  scaleRandomFeatures: boolean;
  useCustomRandomFeatures: boolean;
  randomFeaturesBiasInitializer: string | Initializer | undefined;
  customRandomFeaturesInitializer: string | Initializer | null;
  customRandomFeaturesActivation: string | CallableFunction | null;
  l2Regularization: number;
  gpCovLikelihood: string;
  returnGpCov: boolean;
  returnRandomFeatures: boolean;
  gpOutputKwargs: object;
  _inputNormLayer: tf.layers.Layer | undefined = undefined;
  _randomFeature: Dense | undefined = undefined;
  _gpCovLayer: tf.layers.Layer | undefined = undefined;
  _gpOutputLayer: tf.layers.Layer | undefined = undefined;
  _gpOutputBias: tf.LayerVariable | undefined = undefined;

  constructor(
    units: number,
    numInducing: number = 1024,
    gpKernelType: string = 'gaussian',
    gpKernelScale: number = 1,
    gpOutputBias: number = 0,
    normalizeInput: boolean = false,
    gpKernelScaleTrainable: boolean = false,
    gpOutputBiasTrainable: boolean = false,
    gpCovMomentum: number = -1,
    gpCovRidgePenalty: number = 1,
    scaleRandomFeatures: boolean = true,
    useCustomRandomFeatures: boolean = true,
    customRandomFeaturesInitializer: Initializer | null = null,
    customRandomFeaturesActivation: CallableFunction | null = null,
    l2Regularization: number = 0.000001,
    gpCovLikelihood: string = 'gaussian',
    returnGpCov: boolean = true,
    returnRandomFeatures: boolean = false,
    dtype: tf.DataType | null = null,
    name: string = 'randomFeatureGaussianProcess',
    config?: any
  ) {
    super({ name: name, dtype: dtype, ...config } || {});
    this.units = units;
    this.numInducing = numInducing;

    this.normalizeInput = normalizeInput;
    this.gpInputScale = 1 / tf.sqrt(tf.scalar(gpKernelScale)).arraySync();
    // @ts-ignore
    this.gpFeatureScale = tf.sqrt(tf.scalar(2).div(tf.scalar(numInducing))).arraySync();

    this.scaleRandomFeatures = scaleRandomFeatures;
    this.returnRandomFeatures = returnRandomFeatures;
    this.returnGpCov = returnGpCov;

    this.gpKernelType = gpKernelType;
    this.gpKernelScale = gpKernelScale;
    this.gpOutputBias = gpOutputBias;
    this.gpKernelScaleTrainable = gpKernelScaleTrainable;
    this.gpOutputBiasTrainable = gpOutputBiasTrainable;

    this.useCustomRandomFeatures = useCustomRandomFeatures;
    this.customRandomFeaturesInitializer = customRandomFeaturesInitializer;
    this.customRandomFeaturesActivation = customRandomFeaturesActivation;

    this.l2Regularization = l2Regularization;
    this.gpOutputKwargs = config;

    this.gpCovMomentum = gpCovMomentum;
    this.gpCovRidgePenalty = gpCovRidgePenalty;
    this.gpCovLikelihood = gpCovLikelihood;

    if (this.useCustomRandomFeatures) {
      this.randomFeaturesBiasInitializer = tf.initializers.randomUniform({
        minval: 0,
        maxval: 2 * Math.PI,
      });
      if (!this.customRandomFeaturesInitializer) {
        this.customRandomFeaturesInitializer = tf.initializers.randomNormal({ stddev: 1 });
      }
      if (!this.customRandomFeaturesActivation) {
        this.customRandomFeaturesActivation = tf.cos;
      }
    }
  }

  build(inputShape: Shape | Shape[]) {
    // Defines model layers
    let currInputShape = inputShape;
    if (this.normalizeInput) {
      this._inputNormLayer = tf.layers.layerNormalization({ name: 'gpInputNormalization' });
      this._inputNormLayer.build(inputShape);
      currInputShape = this._inputNormLayer.computeOutputShape(inputShape);
    }

    this._randomFeature = this.makeRandomFeatureLayer('gpRandomFeature');
    // @ts-ignore
    this._randomFeature.build(currInputShape);
    // @ts-ignore
    currInputShape = this._randomFeature.computeOutputShape(inputShape);

    if (this.returnGpCov) {
      this._gpCovLayer = new LaplaceRandomFeatureCovariance(
        this.gpCovMomentum,
        this.gpCovRidgePenalty,
        this.gpCovLikelihood,
        this.dtype,
        'gpCovariance'
      );
      // @ts-ignore
      this._gpCovLayer.build(currInputShape);
    }

    this._gpOutputLayer = tf.layers.dense({
      units: this.units,
      useBias: false,
      kernelRegularizer: tf.regularizers.l2({ l2: this.l2Regularization }),
      dtype: this.dtype,
      name: 'gpOutputWeights',
    });
    this._gpOutputLayer.build(currInputShape);

    this._gpOutputBias = this.addWeight(
      'gpOutputBias',
      [this.units],
      this.dtype,
      new Zeros(),
      undefined,
      this.gpOutputBiasTrainable
    );

    this.built = true;
  }

  makeRandomFeatureLayer(name: string) {
    // Defined random feature layer depending on kernel type
    let customRandomFeatureLayer;
    if (!this.useCustomRandomFeatures) {
      console.error('random fourier implemented');
    }

    if (this.gpKernelType === 'linear') {
      console.error('linear not implemented');
    } else {
      serialization.registerClass(Cos);
      customRandomFeatureLayer = tf.layers.dense({
        units: this.numInducing,
        useBias: true,
        // @ts-ignore
        activation: 'cos',
        // @ts-ignore
        kernelInitializer: this.customRandomFeaturesInitializer,
        biasInitializer: this.randomFeaturesBiasInitializer,
        trainable: false,
        name: name,
      });
    }

    return customRandomFeatureLayer;
  }

  resetCovarianceMatrix() {
    // Resets covariance matrix of GP layer
    // @ts-ignore
    this._gpCovLayer.resetPrecisionMatrix();
  }

  call(inputs: Tensor | Tensor[], kwargs: Kwargs) {
    const training = kwargs['training'];
    // Computes random features
    let gpInputs = inputs;
    if (this.normalizeInput) {
      // @ts-ignore
      gpInputs = this._inputNormLayer.call(gpInputs);
    } else if (this.useCustomRandomFeatures) {
      // Supports lengthscale for custom random feature layer by directly rescaling the input.\
      // @ts-ignore
      const gpInputScale = tf.scalar(this.gpInputScale, inputs[0].dtype);
      // @ts-ignore
      gpInputs = gpInputs.map((input) => input.mul(gpInputScale));
    }

    // @ts-ignore
    let gpFeature = this._randomFeature.call(gpInputs, {});

    if (this.scaleRandomFeatures) {
      // Scale random feature by 2. / sqrt(numInducing)
      // @ts-ignore
      const gpFeatureScale = tf.scalar(this.gpFeatureScale, inputs[0].dtype);
      // @ts-ignore
      gpFeature = gpFeature.mul(gpFeatureScale);
    }

    // Computes posterior center (ie MAP estimate) and variance
    // @ts-ignore
    const gpOutput = tf.add(this._gpOutputLayer.call(gpFeature), this._gpOutputBias.read());

    let gpCovmat;
    if (this.returnGpCov) {
      // @ts-ignore
      gpCovmat = this._gpCovLayer.call(gpFeature, { gpOutput, training });
    }
    // Assembles model output
    const modelOutput = [gpOutput];
    if (this.returnGpCov && !training) {
      // @ts-ignore
      modelOutput.push(gpCovmat);
    }
    if (this.returnRandomFeatures) {
      // @ts-ignore
      modelOutput.push(gpFeature);
    }

    return modelOutput;
  }

  get trainableWeights(): LayerVariable[] {
    // @ts-ignore
    const randomFeatureTrainable = this._randomFeature ? this._randomFeature.trainableWeights : [];
    // @ts-ignore
    const gpOutputLayerTrainable = this._gpOutputLayer ? this._gpOutputLayer.trainableWeights : [];
    // @ts-ignore
    const gpCovLayerTrainable = this._gpCovLayer ? this._gpCovLayer.trainableWeights : [];
    // @ts-ignore
    const gpNonTrainable = super.trainableWeights;
    return randomFeatureTrainable
      .concat(gpOutputLayerTrainable)
      .concat(gpCovLayerTrainable)
      .concat(gpNonTrainable);
  }

  get nonTrainableWeights(): LayerVariable[] {
    // @ts-ignore
    const randomFeatureNonTrainable = this._randomFeature
      ? this._randomFeature.nonTrainableWeights
      : [];
    // @ts-ignore
    const gpOutputLayerNonTrainable = this._gpOutputLayer
      ? this._gpOutputLayer.nonTrainableWeights
      : [];
    // @ts-ignore
    const gpCovLayerNonTrainable = this._gpCovLayer ? this._gpCovLayer.nonTrainableWeights : [];
    // @ts-ignore
    const gpNonTrainable = super.nonTrainableWeights;
    return randomFeatureNonTrainable
      .concat(gpOutputLayerNonTrainable)
      .concat(gpCovLayerNonTrainable)
      .concat(gpNonTrainable);
  }

  computeOutputShape(inputShape: Shape) {
    // @ts-ignore
    return this._gpOutputLayer.computeOutputShape(inputShape);
  }

  /**
   * The static className getter is required by the
   * registration step
   */
  static get className() {
    return 'RandomFeatureGaussianProcess';
  }
}

tf.serialization.registerClass(RandomFeatureGaussianProcess);

export function meanFieldLogits(
  logits: Tensor,
  covarianceMatrix: Tensor,
  meanFieldFactor: number = 1
): Tensor {
  if (!meanFieldFactor || meanFieldFactor < 0) {
    return logits;
  }
  // Compute standard deviation
  const variances = diagPart(covarianceMatrix);

  // Compute scaling coefficient for mean-field approximation
  let logitsScale = tf.sqrt(tf.add(tf.scalar(1), tf.mul(variances, tf.scalar(meanFieldFactor))));

  if (logits.shape.length > 1) {
    // Cast logitsScale to compatible dimension
    logitsScale = tf.expandDims(logitsScale, -1);
  }
  return tf.div(logits, logitsScale);
}

1	// Adapted from https://github.com/tensorflow/models/blob/master/official/nlp/modeling/layers/gaussian_process.py
2
3	import * as tf from '@tensorflow/tfjs';
4	import { LayerVariable, Shape, Tensor } from '@tensorflow/tfjs';
5	import { serialization } from '@tensorflow/tfjs-core';
6	import { Initializer, Zeros } from '@tensorflow/tfjs-layers/dist/initializers';
7	import { Dense } from '@tensorflow/tfjs-layers/dist/layers/core';
8	import { Cos } from './cos';
9	import { LaplaceRandomFeatureCovariance } from './laplaceRandomFeatureCovariance';
10	import { Kwargs } from './spectralNormalizationLayer';
11	import { diagPart } from './tfcUtils';
12
13	export class RandomFeatureGaussianProcess extends tf.layers.Layer {
14	units: number;
15	numInducing: number;
16	gpKernelType: string;
17	gpKernelScale: number;
18	gpOutputBias: number;
19	normalizeInput: boolean;
20	gpInputScale: number;
21	gpFeatureScale: number;
22	gpKernelScaleTrainable: boolean;
23	gpOutputBiasTrainable: boolean;
24	gpCovMomentum: number;
25	gpCovRidgePenalty: number;
26	scaleRandomFeatures: boolean;
27	useCustomRandomFeatures: boolean;
28	randomFeaturesBiasInitializer: string \| Initializer \| undefined;
29	customRandomFeaturesInitializer: string \| Initializer \| null;
30	customRandomFeaturesActivation: string \| CallableFunction \| null;
31	l2Regularization: number;
32	gpCovLikelihood: string;
33	returnGpCov: boolean;
34	returnRandomFeatures: boolean;
35	gpOutputKwargs: object;
NEW 36	_inputNormLayer: tf.layers.Layer \| undefined = undefined;	×
NEW 37	_randomFeature: Dense \| undefined = undefined;	×
NEW 38	_gpCovLayer: tf.layers.Layer \| undefined = undefined;	×
NEW 39	_gpOutputLayer: tf.layers.Layer \| undefined = undefined;	×
NEW 40	_gpOutputBias: tf.LayerVariable \| undefined = undefined;	×
41
42	constructor(
43	units: number,
44	numInducing: number = 1024,	×
45	gpKernelType: string = 'gaussian',	×
46	gpKernelScale: number = 1,	×
47	gpOutputBias: number = 0,	×
48	normalizeInput: boolean = false,	×
49	gpKernelScaleTrainable: boolean = false,	×
50	gpOutputBiasTrainable: boolean = false,	×
51	gpCovMomentum: number = -1,	×
52	gpCovRidgePenalty: number = 1,	×
53	scaleRandomFeatures: boolean = true,	×
54	useCustomRandomFeatures: boolean = true,	×
55	customRandomFeaturesInitializer: Initializer \| null = null,	×
56	customRandomFeaturesActivation: CallableFunction \| null = null,	×
57	l2Regularization: number = 0.000001,	×
58	gpCovLikelihood: string = 'gaussian',	×
59	returnGpCov: boolean = true,	×
60	returnRandomFeatures: boolean = false,	×
61	dtype: tf.DataType \| null = null,	×
62	name: string = 'randomFeatureGaussianProcess',	×
63	config?: any
64	) {
NEW 65	super({ name: name, dtype: dtype, ...config } \|\| {});	×
NEW 66	this.units = units;	×
NEW 67	this.numInducing = numInducing;	×
68
NEW 69	this.normalizeInput = normalizeInput;	×
NEW 70	this.gpInputScale = 1 / tf.sqrt(tf.scalar(gpKernelScale)).arraySync();	×
71	// @ts-ignore
NEW 72	this.gpFeatureScale = tf.sqrt(tf.scalar(2).div(tf.scalar(numInducing))).arraySync();	×
73
NEW 74	this.scaleRandomFeatures = scaleRandomFeatures;	×
NEW 75	this.returnRandomFeatures = returnRandomFeatures;	×
NEW 76	this.returnGpCov = returnGpCov;	×
77
NEW 78	this.gpKernelType = gpKernelType;	×
NEW 79	this.gpKernelScale = gpKernelScale;	×
NEW 80	this.gpOutputBias = gpOutputBias;	×
NEW 81	this.gpKernelScaleTrainable = gpKernelScaleTrainable;	×
NEW 82	this.gpOutputBiasTrainable = gpOutputBiasTrainable;	×
83
NEW 84	this.useCustomRandomFeatures = useCustomRandomFeatures;	×
NEW 85	this.customRandomFeaturesInitializer = customRandomFeaturesInitializer;	×
NEW 86	this.customRandomFeaturesActivation = customRandomFeaturesActivation;	×
87
NEW 88	this.l2Regularization = l2Regularization;	×
NEW 89	this.gpOutputKwargs = config;	×
90
NEW 91	this.gpCovMomentum = gpCovMomentum;	×
NEW 92	this.gpCovRidgePenalty = gpCovRidgePenalty;	×
NEW 93	this.gpCovLikelihood = gpCovLikelihood;	×
94
NEW 95	if (this.useCustomRandomFeatures) {	×
NEW 96	this.randomFeaturesBiasInitializer = tf.initializers.randomUniform({	×
97	minval: 0,
98	maxval: 2 * Math.PI,
99	});
NEW 100	if (!this.customRandomFeaturesInitializer) {	×
NEW 101	this.customRandomFeaturesInitializer = tf.initializers.randomNormal({ stddev: 1 });	×
102	}
NEW 103	if (!this.customRandomFeaturesActivation) {	×
NEW 104	this.customRandomFeaturesActivation = tf.cos;	×
105	}
106	}
107	}
108
109	build(inputShape: Shape \| Shape[]) {
110	// Defines model layers
NEW 111	let currInputShape = inputShape;	×
NEW 112	if (this.normalizeInput) {	×
NEW 113	this._inputNormLayer = tf.layers.layerNormalization({ name: 'gpInputNormalization' });	×
NEW 114	this._inputNormLayer.build(inputShape);	×
NEW 115	currInputShape = this._inputNormLayer.computeOutputShape(inputShape);	×
116	}
117
NEW 118	this._randomFeature = this.makeRandomFeatureLayer('gpRandomFeature');	×
119	// @ts-ignore
NEW 120	this._randomFeature.build(currInputShape);	×
121	// @ts-ignore
NEW 122	currInputShape = this._randomFeature.computeOutputShape(inputShape);	×
123
NEW 124	if (this.returnGpCov) {	×
NEW 125	this._gpCovLayer = new LaplaceRandomFeatureCovariance(	×
126	this.gpCovMomentum,
127	this.gpCovRidgePenalty,
128	this.gpCovLikelihood,
129	this.dtype,
130	'gpCovariance'
131	);
132	// @ts-ignore
NEW 133	this._gpCovLayer.build(currInputShape);	×
134	}
135
NEW 136	this._gpOutputLayer = tf.layers.dense({	×
137	units: this.units,
138	useBias: false,
139	kernelRegularizer: tf.regularizers.l2({ l2: this.l2Regularization }),
140	dtype: this.dtype,
141	name: 'gpOutputWeights',
142	});
NEW 143	this._gpOutputLayer.build(currInputShape);	×
144
NEW 145	this._gpOutputBias = this.addWeight(	×
146	'gpOutputBias',
147	[this.units],
148	this.dtype,
149	new Zeros(),
150	undefined,
151	this.gpOutputBiasTrainable
152	);
153
NEW 154	this.built = true;	×
155	}
156
157	makeRandomFeatureLayer(name: string) {
158	// Defined random feature layer depending on kernel type
159	let customRandomFeatureLayer;
NEW 160	if (!this.useCustomRandomFeatures) {	×
NEW 161	console.error('random fourier implemented');	×
162	}
163
NEW 164	if (this.gpKernelType === 'linear') {	×
NEW 165	console.error('linear not implemented');	×
166	} else {
NEW 167	serialization.registerClass(Cos);	×
NEW 168	customRandomFeatureLayer = tf.layers.dense({	×
169	units: this.numInducing,
170	useBias: true,
171	// @ts-ignore
172	activation: 'cos',
173	// @ts-ignore
174	kernelInitializer: this.customRandomFeaturesInitializer,
175	biasInitializer: this.randomFeaturesBiasInitializer,
176	trainable: false,
177	name: name,
178	});
179	}
180
NEW 181	return customRandomFeatureLayer;	×
182	}
183
184	resetCovarianceMatrix() {
185	// Resets covariance matrix of GP layer
186	// @ts-ignore
NEW 187	this._gpCovLayer.resetPrecisionMatrix();	×
188	}
189
190	call(inputs: Tensor \| Tensor[], kwargs: Kwargs) {
NEW 191	const training = kwargs['training'];	×
192	// Computes random features
NEW 193	let gpInputs = inputs;	×
NEW 194	if (this.normalizeInput) {	×
195	// @ts-ignore
NEW 196	gpInputs = this._inputNormLayer.call(gpInputs);	×
NEW 197	} else if (this.useCustomRandomFeatures) {	×
198	// Supports lengthscale for custom random feature layer by directly rescaling the input.\
199	// @ts-ignore
NEW 200	const gpInputScale = tf.scalar(this.gpInputScale, inputs[0].dtype);	×
201	// @ts-ignore
NEW 202	gpInputs = gpInputs.map((input) => input.mul(gpInputScale));	×
203	}
204
205	// @ts-ignore
NEW 206	let gpFeature = this._randomFeature.call(gpInputs, {});	×
207
NEW 208	if (this.scaleRandomFeatures) {	×
209	// Scale random feature by 2. / sqrt(numInducing)
210	// @ts-ignore
NEW 211	const gpFeatureScale = tf.scalar(this.gpFeatureScale, inputs[0].dtype);	×
212	// @ts-ignore
NEW 213	gpFeature = gpFeature.mul(gpFeatureScale);	×
214	}
215
216	// Computes posterior center (ie MAP estimate) and variance
217	// @ts-ignore
NEW 218	const gpOutput = tf.add(this._gpOutputLayer.call(gpFeature), this._gpOutputBias.read());	×
219
220	let gpCovmat;
NEW 221	if (this.returnGpCov) {	×
222	// @ts-ignore
NEW 223	gpCovmat = this._gpCovLayer.call(gpFeature, { gpOutput, training });	×
224	}
225	// Assembles model output
NEW 226	const modelOutput = [gpOutput];	×
NEW 227	if (this.returnGpCov && !training) {	×
228	// @ts-ignore
NEW 229	modelOutput.push(gpCovmat);	×
230	}
NEW 231	if (this.returnRandomFeatures) {	×
232	// @ts-ignore
NEW 233	modelOutput.push(gpFeature);	×
234	}
235
NEW 236	return modelOutput;	×
237	}
238
239	get trainableWeights(): LayerVariable[] {
240	// @ts-ignore
NEW 241	const randomFeatureTrainable = this._randomFeature ? this._randomFeature.trainableWeights : [];	×
242	// @ts-ignore
NEW 243	const gpOutputLayerTrainable = this._gpOutputLayer ? this._gpOutputLayer.trainableWeights : [];	×
244	// @ts-ignore
NEW 245	const gpCovLayerTrainable = this._gpCovLayer ? this._gpCovLayer.trainableWeights : [];	×
246	// @ts-ignore
NEW 247	const gpNonTrainable = super.trainableWeights;	×
NEW 248	return randomFeatureTrainable	×
249	.concat(gpOutputLayerTrainable)
250	.concat(gpCovLayerTrainable)
251	.concat(gpNonTrainable);
252	}
253
254	get nonTrainableWeights(): LayerVariable[] {
255	// @ts-ignore
NEW 256	const randomFeatureNonTrainable = this._randomFeature	×
257	? this._randomFeature.nonTrainableWeights
258	: [];
259	// @ts-ignore
NEW 260	const gpOutputLayerNonTrainable = this._gpOutputLayer	×
261	? this._gpOutputLayer.nonTrainableWeights
262	: [];
263	// @ts-ignore
NEW 264	const gpCovLayerNonTrainable = this._gpCovLayer ? this._gpCovLayer.nonTrainableWeights : [];	×
265	// @ts-ignore
NEW 266	const gpNonTrainable = super.nonTrainableWeights;	×
NEW 267	return randomFeatureNonTrainable	×
268	.concat(gpOutputLayerNonTrainable)
269	.concat(gpCovLayerNonTrainable)
270	.concat(gpNonTrainable);
271	}
272
273	computeOutputShape(inputShape: Shape) {
274	// @ts-ignore
NEW 275	return this._gpOutputLayer.computeOutputShape(inputShape);	×
276	}
277
278	/**
279	* The static className getter is required by the
280	* registration step
281	*/
282	static get className() {
283	return 'RandomFeatureGaussianProcess';	76✔
284	}
285	}
286
287	tf.serialization.registerClass(RandomFeatureGaussianProcess);	19✔
288
289	export function meanFieldLogits(
290	logits: Tensor,
291	covarianceMatrix: Tensor,
292	meanFieldFactor: number = 1	×
293	): Tensor {
NEW 294	if (!meanFieldFactor \|\| meanFieldFactor < 0) {	×
NEW 295	return logits;	×
296	}
297	// Compute standard deviation
NEW 298	const variances = diagPart(covarianceMatrix);	×
299
300	// Compute scaling coefficient for mean-field approximation
NEW 301	let logitsScale = tf.sqrt(tf.add(tf.scalar(1), tf.mul(variances, tf.scalar(meanFieldFactor))));	×
302
NEW 303	if (logits.shape.length > 1) {	×
304	// Cast logitsScale to compatible dimension
NEW 305	logitsScale = tf.expandDims(logitsScale, -1);	×
306	}
NEW 307	return tf.div(logits, logitsScale);	×
308	}

vanvalenlab / deepcell-label / 4578689396

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous