/**
|
* @license
|
* Copyright 2018 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 * as broadcast_util from '../../ops/broadcast_util';
|
import {sizeFromShape} from '../../util';
|
import {getChannels} from '../packing_util';
|
|
import {GPGPUProgram} from './gpgpu_math';
|
import {getCoordsDataType} from './shader_compiler';
|
|
const CHECK_NAN_SNIPPET = `
|
result.r = isNaN.r > 0. ? NAN : result.r;
|
result.g = isNaN.g > 0. ? NAN : result.g;
|
result.b = isNaN.b > 0. ? NAN : result.b;
|
result.a = isNaN.a > 0. ? NAN : result.a;
|
`;
|
|
// We do the same as in ./binaryop_gpu, with vec4 and ivec4.
|
// On Linux, the vectorized implementation produces NaNs when a and b are 0.
|
export const DIV = `
|
// vec4 one = vec4(equal(a, b));
|
// return one + (vec4(1.0) - one) * a / b;
|
vec4 result = a / b;
|
if(a.x == b.x) {
|
result.x = 1.;
|
}
|
if(a.y == b.y) {
|
result.y = 1.;
|
}
|
if(a.z == b.z) {
|
result.z = 1.;
|
}
|
if(a.w == b.w) {
|
result.w = 1.;
|
}
|
|
return result;
|
`;
|
|
export const INT_DIV = `
|
ivec4 ia = round(a);
|
ivec4 ib = round(b);
|
bvec4 cond = notEqual(ib, ivec4(0));
|
ivec4 result = ivec4(0);
|
vec4 s = sign(a) * sign(b);
|
|
// Windows (D3D) wants guaranteed non-zero int division at compile-time.
|
if (cond[0]) {
|
result[0] = idiv(ia[0], ib[0], s[0]);
|
}
|
if (cond[1]) {
|
result[1] = idiv(ia[1], ib[1], s[1]);
|
}
|
if (cond[2]) {
|
result[2] = idiv(ia[2], ib[2], s[2]);
|
}
|
if (cond[3]) {
|
result[3] = idiv(ia[3], ib[3], s[3]);
|
}
|
return vec4(result);
|
`;
|
|
export const POW = `
|
// isModRound1 has 1 for components with round(mod(b, 2.0)) == 1, 0 otherwise.
|
vec4 isModRound1 = vec4(equal(round(mod(b, 2.0)), ivec4(1)));
|
vec4 multiplier = sign(a) * isModRound1 + (vec4(1.0) - isModRound1);
|
vec4 result = multiplier * pow(abs(a), b);
|
|
// Ensure that a^0 = 1, including 0^0 = 1 as this correspond to TF and JS
|
bvec4 isExpZero = equal(b, vec4(0.0));
|
result.r = isExpZero.r ? 1.0 : result.r;
|
result.g = isExpZero.g ? 1.0 : result.g;
|
result.b = isExpZero.b ? 1.0 : result.b;
|
result.a = isExpZero.a ? 1.0 : result.a;
|
|
vec4 isNaN = vec4(lessThan(a, vec4(0.0))) * vec4(lessThan(floor(b), b));
|
` +
|
CHECK_NAN_SNIPPET + `
|
return result;
|
`;
|
|
export const PRELU = `
|
vec4 aLessThanZero = vec4(lessThan(a, vec4(0.)));
|
return (aLessThanZero * (b * a)) + ((vec4(1.0) - aLessThanZero) * a);
|
`;
|
|
export const ELU_DER = `
|
vec4 bGTEZero = vec4(greaterThanEqual(b, vec4(0.)));
|
return (bGTEZero * a) + ((vec4(1.0) - bGTEZero) * (a * (b + vec4(1.0))));
|
`;
|
|
export const ATAN2 = `
|
vec4 result = atan(a, b);
|
vec4 isNaN = min(vec4(isnan(a)) + vec4(isnan(b)), vec4(1.0));
|
` +
|
CHECK_NAN_SNIPPET + `
|
return result;
|
`;
|
|
export const EQUAL = `
|
return vec4(equal(a, b));
|
`;
|
|
export const NOT_EQUAL = `
|
return vec4(notEqual(a, b));
|
`;
|
|
export const LESS = `
|
return vec4(lessThan(a, b));
|
`;
|
|
export const LESS_EQUAL = `
|
return vec4(lessThanEqual(a, b));
|
`;
|
|
export const GREATER = `
|
return vec4(greaterThan(a, b));
|
`;
|
|
export const GREATER_EQUAL = `
|
return vec4(greaterThanEqual(a, b));
|
`;
|
|
export const LOGICAL_AND = `
|
return vec4(
|
vec4(greaterThanEqual(a, vec4(1.0))) *
|
vec4(greaterThanEqual(b, vec4(1.0))));
|
`;
|
|
export const LOGICAL_OR = `
|
return min(
|
vec4(greaterThanEqual(a, vec4(1.0))) +
|
vec4(greaterThanEqual(b, vec4(1.0))),
|
vec4(1.0));
|
`;
|
|
export const MAX = `
|
vec4 result = vec4(max(a, b));
|
vec4 isNaN = min(vec4(isnan(a)) + vec4(isnan(b)), vec4(1.0));
|
` +
|
CHECK_NAN_SNIPPET + `
|
return result;
|
`;
|
|
export const MIN = `
|
vec4 result = vec4(min(a, b));
|
vec4 isNaN = min(vec4(isnan(a)) + vec4(isnan(b)), vec4(1.0));
|
` +
|
CHECK_NAN_SNIPPET + `
|
return result;
|
`;
|
|
export const MOD = `
|
vec4 result = mod(a, b);
|
vec4 isNaN = vec4(equal(b, vec4(0.0)));
|
` +
|
CHECK_NAN_SNIPPET + `
|
return result;
|
`;
|
|
export class BinaryOpPackedProgram implements GPGPUProgram {
|
variableNames = ['A', 'B'];
|
outputShape: number[];
|
userCode: string;
|
supportsBroadcasting = true;
|
packedInputs = true;
|
packedOutput = true;
|
|
constructor(
|
op: string, aShape: number[], bShape: number[],
|
checkOutOfBounds = false) {
|
this.outputShape =
|
broadcast_util.assertAndGetBroadcastShape(aShape, bShape);
|
const rank = this.outputShape.length;
|
let checkOutOfBoundsString = '';
|
if (checkOutOfBounds) {
|
if (rank === 0 || sizeFromShape(this.outputShape) === 1) {
|
checkOutOfBoundsString = `
|
result.y = 0.;
|
result.z = 0.;
|
result.w = 0.;
|
`;
|
} else {
|
const dtype = getCoordsDataType(rank);
|
checkOutOfBoundsString = `
|
${dtype} coords = getOutputCoords();
|
`;
|
if (rank === 1) {
|
checkOutOfBoundsString += `
|
result.y = (coords + 1) >= ${this.outputShape[0]} ? 0. : result.y;
|
result.z = 0.;
|
result.w = 0.;
|
`;
|
} else {
|
const channels = getChannels('coords', rank);
|
checkOutOfBoundsString += `
|
bool nextRowOutOfBounds =
|
(${channels[rank - 2]} + 1) >= ${this.outputShape[rank - 2]};
|
bool nextColOutOfBounds =
|
(${channels[rank - 1]} + 1) >= ${this.outputShape[rank - 1]};
|
result.y = nextColOutOfBounds ? 0. : result.y;
|
result.z = nextRowOutOfBounds ? 0. : result.z;
|
result.w = nextColOutOfBounds || nextRowOutOfBounds ? 0. : result.w;
|
`;
|
}
|
}
|
}
|
|
this.userCode = `
|
vec4 binaryOperation(vec4 a, vec4 b) {
|
${op}
|
}
|
|
void main() {
|
vec4 a = getAAtOutCoords();
|
vec4 b = getBAtOutCoords();
|
|
vec4 result = binaryOperation(a, b);
|
${checkOutOfBoundsString}
|
|
setOutput(result);
|
}
|
`;
|
}
|
}
|
