diff --git a/tfjs-core/src/kernel_names.ts b/tfjs-core/src/kernel_names.ts
index 4abbdc1abca..b54d4ca91d7 100644
--- a/tfjs-core/src/kernel_names.ts
+++ b/tfjs-core/src/kernel_names.ts
@@ -39,6 +39,9 @@ export interface FusedBatchNormAttrs {
   varianceEpsilon: number;
 }
 
+export const NotEqual = 'NotEqual';
+export type NotEqualInputs = BinaryInputs;
+
 export const SquaredDifference = 'SquaredDifference';
 export type SquaredDifferenceInputs = BinaryInputs;
 
diff --git a/tfjs-core/src/ops/compare.ts b/tfjs-core/src/ops/compare.ts
index 521d269a8ef..974609234ed 100644
--- a/tfjs-core/src/ops/compare.ts
+++ b/tfjs-core/src/ops/compare.ts
@@ -25,33 +25,6 @@ import {assertAndGetBroadcastShape} from './broadcast_util';
 import {op} from './operation';
 import {zerosLike} from './tensor_ops';
 
-/**
- * Returns the truth value of (a != b) element-wise. Supports broadcasting.
- *
- * We also expose `tf.notEqualStrict` which has the same signature as this op
- * and asserts that `a` and `b` are the same shape (does not broadcast).
- *
- * ```js
- * const a = tf.tensor1d([1, 2, 3]);
- * const b = tf.tensor1d([0, 2, 3]);
- *
- * a.notEqual(b).print();
- * ```
- * @param a The first input tensor.
- * @param b The second input tensor. Must have the same dtype as `a`.
- */
-/** @doc {heading: 'Operations', subheading: 'Logical'} */
-function notEqual_<T extends Tensor>(
-    a: Tensor|TensorLike, b: Tensor|TensorLike): T {
-  let $a = convertToTensor(a, 'a', 'notEqual');
-  let $b = convertToTensor(b, 'b', 'notEqual');
-  [$a, $b] = makeTypesMatch($a, $b);
-  assertAndGetBroadcastShape($a.shape, $b.shape);
-  return ENGINE.runKernelFunc(
-             backend => backend.notEqual($a, $b), {a: $a, b: $b},
-             null /* grad */, 'NotEqual') as T;
-}
-
 /**
  * Strict version of `tf.notEqual` that forces `a` and `b` to be of the same
  * shape.
@@ -273,5 +246,4 @@ export const less = op({less_});
 export const lessEqual = op({lessEqual_});
 export const lessEqualStrict = op({lessEqualStrict_});
 export const lessStrict = op({lessStrict_});
-export const notEqual = op({notEqual_});
 export const notEqualStrict = op({notEqualStrict_});
diff --git a/tfjs-core/src/ops/compare_ops_test.ts b/tfjs-core/src/ops/compare_ops_test.ts
index 45ef5e895c7..35678c90e4b 100644
--- a/tfjs-core/src/ops/compare_ops_test.ts
+++ b/tfjs-core/src/ops/compare_ops_test.ts
@@ -499,279 +499,6 @@ describeWithFlags('equalStrict', ALL_ENVS, () => {
   });
 });
 
-describeWithFlags('notEqual', ALL_ENVS, () => {
-  it('Tensor1D - int32', async () => {
-    let a = tf.tensor1d([1, 4, 5], 'int32');
-    let b = tf.tensor1d([2, 3, 5], 'int32');
-
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0]);
-
-    a = tf.tensor1d([2, 2, 2], 'int32');
-    b = tf.tensor1d([2, 2, 2], 'int32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0]);
-
-    a = tf.tensor1d([0, 0], 'int32');
-    b = tf.tensor1d([3, 3], 'int32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1]);
-  });
-  it('Tensor1D - float32', async () => {
-    let a = tf.tensor1d([1.1, 4.1, 5.1], 'float32');
-    let b = tf.tensor1d([2.2, 3.2, 5.1], 'float32');
-
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0]);
-
-    a = tf.tensor1d([2.31, 2.31, 2.31], 'float32');
-    b = tf.tensor1d([2.31, 2.31, 2.31], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0]);
-
-    a = tf.tensor1d([0.45, 0.123], 'float32');
-    b = tf.tensor1d([3.123, 3.321], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1]);
-  });
-
-  it('upcasts when dtypes dont match', async () => {
-    const a = [1.1, 4.1, 5];
-    const b = [2.2, 3.2, 5];
-
-    let res =
-        tf.notEqual(tf.tensor(a, [3], 'float32'), tf.tensor(b, [3], 'int32'));
-    expect(res.dtype).toBe('bool');
-    expect(res.shape).toEqual([3]);
-    expectArraysClose(await res.data(), [1, 1, 0]);
-
-    res = tf.notEqual(tf.tensor(a, [3], 'int32'), tf.tensor(b, [3], 'bool'));
-    expect(res.dtype).toBe('bool');
-    expect(res.shape).toEqual([3]);
-    expectArraysClose(await res.data(), [0, 1, 1]);
-  });
-
-  it('TensorLike', async () => {
-    const a = [1.1, 4.1, 5.1];
-    const b = [2.2, 3.2, 5.1];
-
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0]);
-  });
-  it('TensorLike Chained', async () => {
-    const a = tf.tensor1d([1.1, 4.1, 5.1], 'float32');
-    const b = [2.2, 3.2, 5.1];
-
-    expectArraysClose(await a.notEqual(b).data(), [1, 1, 0]);
-  });
-  it('mismatched Tensor1D shapes - int32', () => {
-    const a = tf.tensor1d([1, 2], 'int32');
-    const b = tf.tensor1d([1, 2, 3], 'int32');
-    const f = () => {
-      tf.notEqual(a, b);
-    };
-    expect(f).toThrowError();
-  });
-  it('mismatched Tensor1D shapes - float32', () => {
-    const a = tf.tensor1d([1.1, 2.1], 'float32');
-    const b = tf.tensor1d([1.1, 2.1, 3.1], 'float32');
-    const f = () => {
-      tf.notEqual(a, b);
-    };
-    expect(f).toThrowError();
-  });
-  it('NaNs in Tensor1D - float32', async () => {
-    const a = tf.tensor1d([1.1, NaN, 2.1], 'float32');
-    const b = tf.tensor1d([2.1, 3.1, NaN], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1]);
-  });
-  it('works with NaNs', async () => {
-    const a = tf.tensor1d([2, 5, NaN]);
-    const b = tf.tensor1d([4, 5, -1]);
-
-    const res = tf.notEqual(a, b);
-    expect(res.dtype).toBe('bool');
-    expectArraysEqual(await res.data(), [1, 0, 1]);
-  });
-  it('scalar and 1D broadcast', async () => {
-    const a = tf.scalar(2);
-    const b = tf.tensor1d([1, 2, 3, 4, 5, 2]);
-    const res = tf.notEqual(a, b);
-    expect(res.dtype).toBe('bool');
-    expect(res.shape).toEqual([6]);
-    expectArraysEqual(await res.data(), [1, 0, 1, 1, 1, 0]);
-  });
-
-  // Tensor2D:
-  it('Tensor2D - int32', async () => {
-    let a = tf.tensor2d([[1, 4, 5], [8, 9, 12]], [2, 3], 'int32');
-    let b = tf.tensor2d([[2, 3, 6], [7, 10, 11]], [2, 3], 'int32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 1, 1, 1]);
-
-    a = tf.tensor2d([[0, 0], [1, 1]], [2, 2], 'int32');
-    b = tf.tensor2d([[0, 0], [1, 1]], [2, 2], 'int32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0, 0]);
-  });
-  it('Tensor2D - float32', async () => {
-    let a = tf.tensor2d([[1.1, 4.1, 5.1], [8.1, 9.1, 12.1]], [2, 3], 'float32');
-    let b =
-        tf.tensor2d([[2.1, 4.1, 5.1], [7.1, 10.1, 11.1]], [2, 3], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 0, 0, 1, 1, 1]);
-
-    a = tf.tensor2d([[0.2, 0.2], [1.2, 1.2]], [2, 2], 'float32');
-    b = tf.tensor2d([[0.2, 0.2], [1.2, 1.2]], [2, 2], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0, 0]);
-  });
-  it('broadcasting Tensor2D shapes - int32', async () => {
-    const a = tf.tensor2d([[3], [7]], [2, 1], 'int32');
-    const b = tf.tensor2d([[2, 3, 4], [7, 8, 9]], [2, 3], 'int32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 0, 1, 0, 1, 1]);
-  });
-  it('broadcasting Tensor2D shapes - float32', async () => {
-    const a = tf.tensor2d([[1.1], [7.1]], [2, 1], 'float32');
-    const b =
-        tf.tensor2d([[0.1, 1.1, 2.1], [7.1, 8.1, 9.1]], [2, 3], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 0, 1, 0, 1, 1]);
-  });
-  it('NaNs in Tensor2D - float32', async () => {
-    const a = tf.tensor2d([[1.1, NaN], [1.1, NaN]], [2, 2], 'float32');
-    const b = tf.tensor2d([[0.1, NaN], [1.1, NaN]], [2, 2], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0, 1]);
-  });
-  it('2D and scalar broadcast', async () => {
-    const a = tf.tensor2d([1, 2, 3, 2, 5, 6], [2, 3]);
-    const b = tf.scalar(2);
-    const res = tf.notEqual(a, b);
-    expect(res.dtype).toBe('bool');
-    expect(res.shape).toEqual([2, 3]);
-    expectArraysEqual(await res.data(), [1, 0, 1, 0, 1, 1]);
-  });
-  it('2D and 2D broadcast each with 1 dim', async () => {
-    const a = tf.tensor2d([1, 2, 5], [1, 3]);
-    const b = tf.tensor2d([5, 1], [2, 1]);
-    const res = tf.notEqual(a, b);
-    expect(res.dtype).toBe('bool');
-    expect(res.shape).toEqual([2, 3]);
-    expectArraysEqual(await res.data(), [1, 1, 0, 0, 1, 1]);
-  });
-
-  // Tensor3D:
-  it('Tensor3D - int32', async () => {
-    let a =
-        tf.tensor3d([[[1], [4], [5]], [[8], [9], [12]]], [2, 3, 1], 'int32');
-    let b =
-        tf.tensor3d([[[2], [3], [6]], [[7], [10], [12]]], [2, 3, 1], 'int32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 1, 1, 0]);
-
-    a = tf.tensor3d([[[0], [0], [0]], [[1], [1], [1]]], [2, 3, 1], 'int32');
-    b = tf.tensor3d([[[0], [0], [0]], [[1], [1], [1]]], [2, 3, 1], 'int32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0, 0, 0, 0]);
-  });
-  it('Tensor3D - float32', async () => {
-    let a = tf.tensor3d(
-        [[[1.1], [4.1], [5.1]], [[8.1], [9.1], [12.1]]], [2, 3, 1], 'float32');
-    let b = tf.tensor3d(
-        [[[2.1], [3.1], [6.1]], [[7.1], [10.1], [12.1]]], [2, 3, 1], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 1, 1, 0]);
-
-    a = tf.tensor3d(
-        [[[0.1], [0.1], [0.1]], [[1.1], [1.1], [1.1]]], [2, 3, 1], 'float32');
-    b = tf.tensor3d(
-        [[[0.1], [0.1], [0.1]], [[1.1], [1.1], [1.1]]], [2, 3, 1], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0, 0, 0, 0]);
-  });
-  it('broadcasting Tensor3D shapes - int32', async () => {
-    const a = tf.tensor3d(
-        [[[1, 0], [2, 3], [4, 5]], [[6, 7], [9, 8], [10, 11]]], [2, 3, 2],
-        'int32');
-    const b =
-        tf.tensor3d([[[1], [2], [3]], [[7], [10], [9]]], [2, 3, 1], 'int32');
-    expectArraysClose(
-        await tf.notEqual(a, b).data(), [0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1]);
-  });
-  it('broadcasting Tensor3D shapes - float32', async () => {
-    const a = tf.tensor3d(
-        [
-          [[1.1, 0.1], [2.1, 3.1], [4.1, 5.1]],
-          [[6.1, 7.1], [9.1, 8.1], [10.1, 11.1]]
-        ],
-        [2, 3, 2], 'float32');
-    const b = tf.tensor3d(
-        [[[1.1], [2.1], [3.1]], [[7.1], [10.1], [9.1]]], [2, 3, 1], 'float32');
-    expectArraysClose(
-        await tf.notEqual(a, b).data(), [0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1]);
-  });
-  it('NaNs in Tensor3D - float32', async () => {
-    const a = tf.tensor3d(
-        [[[1.1], [NaN], [1.1]], [[0.1], [0.1], [0.1]]], [2, 3, 1], 'float32');
-    const b = tf.tensor3d(
-        [[[0.1], [0.1], [1.1]], [[1.1], [0.1], [NaN]]], [2, 3, 1], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0, 1, 0, 1]);
-  });
-  it('3D and scalar', async () => {
-    const a = tf.tensor3d([1, 2, 3, 4, 5, -1], [2, 3, 1]);
-    const b = tf.scalar(-1);
-    const res = tf.notEqual(a, b);
-    expect(res.dtype).toBe('bool');
-    expect(res.shape).toEqual([2, 3, 1]);
-    expectArraysEqual(await res.data(), [1, 1, 1, 1, 1, 0]);
-  });
-
-  // Tensor4D:
-  it('Tensor4D - int32', async () => {
-    let a = tf.tensor4d([1, 4, 5, 8], [2, 2, 1, 1], 'int32');
-    let b = tf.tensor4d([2, 3, 6, 8], [2, 2, 1, 1], 'int32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 0]);
-
-    a = tf.tensor4d([0, 1, 2, 3], [2, 2, 1, 1], 'int32');
-    b = tf.tensor4d([0, 1, 2, 3], [2, 2, 1, 1], 'int32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0, 0]);
-
-    a = tf.tensor4d([1, 1, 1, 1], [2, 2, 1, 1], 'int32');
-    b = tf.tensor4d([2, 2, 2, 2], [2, 2, 1, 1], 'int32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 1]);
-  });
-  it('Tensor4D - float32', async () => {
-    let a = tf.tensor4d([1.1, 4.1, 5.1, 8.1], [2, 2, 1, 1], 'float32');
-    let b = tf.tensor4d([2.1, 3.1, 6.1, 8.1], [2, 2, 1, 1], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 0]);
-
-    a = tf.tensor4d([0.1, 1.1, 2.2, 3.3], [2, 2, 1, 1], 'float32');
-    b = tf.tensor4d([0.1, 1.1, 2.2, 3.3], [2, 2, 1, 1], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0, 0]);
-
-    a = tf.tensor4d([0.1, 0.1, 0.1, 0.1], [2, 2, 1, 1], 'float32');
-    b = tf.tensor4d([1.1, 1.1, 1.1, 1.1], [2, 2, 1, 1], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 1]);
-  });
-  it('broadcasting Tensor4D shapes - int32', async () => {
-    const a = tf.tensor4d([1, 2, 5, 9], [2, 2, 1, 1], 'int32');
-    const b = tf.tensor4d(
-        [[[[1, 2]], [[3, 4]]], [[[5, 6]], [[7, 8]]]], [2, 2, 1, 2], 'int32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [0, 1, 1, 1, 0, 1, 1, 1]);
-  });
-  it('broadcasting Tensor4D shapes - float32', async () => {
-    const a = tf.tensor4d([1.1, 2.1, 5.1, 9.1], [2, 2, 1, 1], 'float32');
-    const b = tf.tensor4d(
-        [[[[1.1, 2.1]], [[3.1, 4.1]]], [[[5.1, 6.1]], [[7.1, 8.1]]]],
-        [2, 2, 1, 2], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [0, 1, 1, 1, 0, 1, 1, 1]);
-  });
-  it('NaNs in Tensor4D - float32', async () => {
-    const a = tf.tensor4d([1.1, NaN, 1.1, 0.1], [2, 2, 1, 1], 'float32');
-    const b = tf.tensor4d([0.1, 1.1, 1.1, NaN], [2, 2, 1, 1], 'float32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0, 1]);
-  });
-
-  it('throws when passed a as a non-tensor', () => {
-    expect(() => tf.notEqual({} as tf.Tensor, tf.scalar(1)))
-        .toThrowError(/Argument 'a' passed to 'notEqual' must be a Tensor/);
-  });
-  it('throws when passed b as a non-tensor', () => {
-    expect(() => tf.notEqual(tf.scalar(1), {} as tf.Tensor))
-        .toThrowError(/Argument 'b' passed to 'notEqual' must be a Tensor/);
-  });
-
-  it('accepts a tensor-like object', async () => {
-    const a = tf.tensor1d([1, 4, 5], 'int32');
-    const b = tf.tensor1d([2, 3, 5], 'int32');
-    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0]);
-  });
-});
-
 describeWithFlags('notEqualStrict', ALL_ENVS, () => {
   it('Tensor1D - int32', async () => {
     let a = tf.tensor1d([1, 4, 5], 'int32');
diff --git a/tfjs-core/src/ops/not_equal.ts b/tfjs-core/src/ops/not_equal.ts
new file mode 100644
index 00000000000..f210da73492
--- /dev/null
+++ b/tfjs-core/src/ops/not_equal.ts
@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright 2020 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 {ENGINE, ForwardFunc} from '../engine';
+import {NotEqual, NotEqualInputs} from '../kernel_names';
+import {Tensor} from '../tensor';
+import {NamedTensorMap} from '../tensor_types';
+import {makeTypesMatch} from '../tensor_util';
+import {convertToTensor} from '../tensor_util_env';
+import {TensorLike} from '../types';
+
+import {assertAndGetBroadcastShape} from './broadcast_util';
+import {op} from './operation';
+
+/**
+ * Returns the truth value of (a != b) element-wise. Supports broadcasting.
+ *
+ * We also expose `tf.notEqualStrict` which has the same signature as this op
+ * and asserts that `a` and `b` are the same shape (does not broadcast).
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2, 3]);
+ * const b = tf.tensor1d([0, 2, 3]);
+ *
+ * a.notEqual(b).print();
+ * ```
+ * @param a The first input tensor.
+ * @param b The second input tensor. Must have the same dtype as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+function notEqual_<T extends Tensor>(
+    a: Tensor|TensorLike, b: Tensor|TensorLike): T {
+  let $a = convertToTensor(a, 'a', 'notEqual');
+  let $b = convertToTensor(b, 'b', 'notEqual');
+  [$a, $b] = makeTypesMatch($a, $b);
+
+  assertAndGetBroadcastShape($a.shape, $b.shape);
+
+  const forward: ForwardFunc<Tensor> = (backend) => backend.notEqual($a, $b);
+
+  const inputs: NotEqualInputs = {a: $a, b: $b};
+
+  return ENGINE.runKernelFunc(
+             forward, inputs as {} as NamedTensorMap, null /* grad */,
+             NotEqual) as T;
+}
+
+export const notEqual = op({notEqual_});
diff --git a/tfjs-core/src/ops/not_equal_test.ts b/tfjs-core/src/ops/not_equal_test.ts
new file mode 100644
index 00000000000..94504519c8b
--- /dev/null
+++ b/tfjs-core/src/ops/not_equal_test.ts
@@ -0,0 +1,292 @@
+/**
+ * @license
+ * Copyright 2020 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 tf from '../index';
+import {ALL_ENVS, describeWithFlags} from '../jasmine_util';
+import {expectArraysClose, expectArraysEqual} from '../test_util';
+
+describeWithFlags('notEqual', ALL_ENVS, () => {
+  it('Tensor1D - int32', async () => {
+    let a = tf.tensor1d([1, 4, 5], 'int32');
+    let b = tf.tensor1d([2, 3, 5], 'int32');
+
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0]);
+
+    a = tf.tensor1d([2, 2, 2], 'int32');
+    b = tf.tensor1d([2, 2, 2], 'int32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0]);
+
+    a = tf.tensor1d([0, 0], 'int32');
+    b = tf.tensor1d([3, 3], 'int32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1]);
+  });
+  it('Tensor1D - float32', async () => {
+    let a = tf.tensor1d([1.1, 4.1, 5.1], 'float32');
+    let b = tf.tensor1d([2.2, 3.2, 5.1], 'float32');
+
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0]);
+
+    a = tf.tensor1d([2.31, 2.31, 2.31], 'float32');
+    b = tf.tensor1d([2.31, 2.31, 2.31], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0]);
+
+    a = tf.tensor1d([0.45, 0.123], 'float32');
+    b = tf.tensor1d([3.123, 3.321], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1]);
+  });
+
+  it('upcasts when dtypes dont match', async () => {
+    const a = [1.1, 4.1, 5];
+    const b = [2.2, 3.2, 5];
+
+    let res =
+        tf.notEqual(tf.tensor(a, [3], 'float32'), tf.tensor(b, [3], 'int32'));
+    expect(res.dtype).toBe('bool');
+    expect(res.shape).toEqual([3]);
+    expectArraysClose(await res.data(), [1, 1, 0]);
+
+    res = tf.notEqual(tf.tensor(a, [3], 'int32'), tf.tensor(b, [3], 'bool'));
+    expect(res.dtype).toBe('bool');
+    expect(res.shape).toEqual([3]);
+    expectArraysClose(await res.data(), [0, 1, 1]);
+  });
+
+  it('TensorLike', async () => {
+    const a = [1.1, 4.1, 5.1];
+    const b = [2.2, 3.2, 5.1];
+
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0]);
+  });
+  it('TensorLike Chained', async () => {
+    const a = tf.tensor1d([1.1, 4.1, 5.1], 'float32');
+    const b = [2.2, 3.2, 5.1];
+
+    expectArraysClose(await a.notEqual(b).data(), [1, 1, 0]);
+  });
+  it('mismatched Tensor1D shapes - int32', () => {
+    const a = tf.tensor1d([1, 2], 'int32');
+    const b = tf.tensor1d([1, 2, 3], 'int32');
+    const f = () => {
+      tf.notEqual(a, b);
+    };
+    expect(f).toThrowError();
+  });
+  it('mismatched Tensor1D shapes - float32', () => {
+    const a = tf.tensor1d([1.1, 2.1], 'float32');
+    const b = tf.tensor1d([1.1, 2.1, 3.1], 'float32');
+    const f = () => {
+      tf.notEqual(a, b);
+    };
+    expect(f).toThrowError();
+  });
+  it('NaNs in Tensor1D - float32', async () => {
+    const a = tf.tensor1d([1.1, NaN, 2.1], 'float32');
+    const b = tf.tensor1d([2.1, 3.1, NaN], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1]);
+  });
+  it('works with NaNs', async () => {
+    const a = tf.tensor1d([2, 5, NaN]);
+    const b = tf.tensor1d([4, 5, -1]);
+
+    const res = tf.notEqual(a, b);
+    expect(res.dtype).toBe('bool');
+    expectArraysEqual(await res.data(), [1, 0, 1]);
+  });
+  it('scalar and 1D broadcast', async () => {
+    const a = tf.scalar(2);
+    const b = tf.tensor1d([1, 2, 3, 4, 5, 2]);
+    const res = tf.notEqual(a, b);
+    expect(res.dtype).toBe('bool');
+    expect(res.shape).toEqual([6]);
+    expectArraysEqual(await res.data(), [1, 0, 1, 1, 1, 0]);
+  });
+
+  // Tensor2D:
+  it('Tensor2D - int32', async () => {
+    let a = tf.tensor2d([[1, 4, 5], [8, 9, 12]], [2, 3], 'int32');
+    let b = tf.tensor2d([[2, 3, 6], [7, 10, 11]], [2, 3], 'int32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 1, 1, 1]);
+
+    a = tf.tensor2d([[0, 0], [1, 1]], [2, 2], 'int32');
+    b = tf.tensor2d([[0, 0], [1, 1]], [2, 2], 'int32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0, 0]);
+  });
+  it('Tensor2D - float32', async () => {
+    let a = tf.tensor2d([[1.1, 4.1, 5.1], [8.1, 9.1, 12.1]], [2, 3], 'float32');
+    let b =
+        tf.tensor2d([[2.1, 4.1, 5.1], [7.1, 10.1, 11.1]], [2, 3], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 0, 0, 1, 1, 1]);
+
+    a = tf.tensor2d([[0.2, 0.2], [1.2, 1.2]], [2, 2], 'float32');
+    b = tf.tensor2d([[0.2, 0.2], [1.2, 1.2]], [2, 2], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0, 0]);
+  });
+  it('broadcasting Tensor2D shapes - int32', async () => {
+    const a = tf.tensor2d([[3], [7]], [2, 1], 'int32');
+    const b = tf.tensor2d([[2, 3, 4], [7, 8, 9]], [2, 3], 'int32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 0, 1, 0, 1, 1]);
+  });
+  it('broadcasting Tensor2D shapes - float32', async () => {
+    const a = tf.tensor2d([[1.1], [7.1]], [2, 1], 'float32');
+    const b =
+        tf.tensor2d([[0.1, 1.1, 2.1], [7.1, 8.1, 9.1]], [2, 3], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 0, 1, 0, 1, 1]);
+  });
+  it('NaNs in Tensor2D - float32', async () => {
+    const a = tf.tensor2d([[1.1, NaN], [1.1, NaN]], [2, 2], 'float32');
+    const b = tf.tensor2d([[0.1, NaN], [1.1, NaN]], [2, 2], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0, 1]);
+  });
+  it('2D and scalar broadcast', async () => {
+    const a = tf.tensor2d([1, 2, 3, 2, 5, 6], [2, 3]);
+    const b = tf.scalar(2);
+    const res = tf.notEqual(a, b);
+    expect(res.dtype).toBe('bool');
+    expect(res.shape).toEqual([2, 3]);
+    expectArraysEqual(await res.data(), [1, 0, 1, 0, 1, 1]);
+  });
+  it('2D and 2D broadcast each with 1 dim', async () => {
+    const a = tf.tensor2d([1, 2, 5], [1, 3]);
+    const b = tf.tensor2d([5, 1], [2, 1]);
+    const res = tf.notEqual(a, b);
+    expect(res.dtype).toBe('bool');
+    expect(res.shape).toEqual([2, 3]);
+    expectArraysEqual(await res.data(), [1, 1, 0, 0, 1, 1]);
+  });
+
+  // Tensor3D:
+  it('Tensor3D - int32', async () => {
+    let a =
+        tf.tensor3d([[[1], [4], [5]], [[8], [9], [12]]], [2, 3, 1], 'int32');
+    let b =
+        tf.tensor3d([[[2], [3], [6]], [[7], [10], [12]]], [2, 3, 1], 'int32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 1, 1, 0]);
+
+    a = tf.tensor3d([[[0], [0], [0]], [[1], [1], [1]]], [2, 3, 1], 'int32');
+    b = tf.tensor3d([[[0], [0], [0]], [[1], [1], [1]]], [2, 3, 1], 'int32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0, 0, 0, 0]);
+  });
+  it('Tensor3D - float32', async () => {
+    let a = tf.tensor3d(
+        [[[1.1], [4.1], [5.1]], [[8.1], [9.1], [12.1]]], [2, 3, 1], 'float32');
+    let b = tf.tensor3d(
+        [[[2.1], [3.1], [6.1]], [[7.1], [10.1], [12.1]]], [2, 3, 1], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 1, 1, 0]);
+
+    a = tf.tensor3d(
+        [[[0.1], [0.1], [0.1]], [[1.1], [1.1], [1.1]]], [2, 3, 1], 'float32');
+    b = tf.tensor3d(
+        [[[0.1], [0.1], [0.1]], [[1.1], [1.1], [1.1]]], [2, 3, 1], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0, 0, 0, 0]);
+  });
+  it('broadcasting Tensor3D shapes - int32', async () => {
+    const a = tf.tensor3d(
+        [[[1, 0], [2, 3], [4, 5]], [[6, 7], [9, 8], [10, 11]]], [2, 3, 2],
+        'int32');
+    const b =
+        tf.tensor3d([[[1], [2], [3]], [[7], [10], [9]]], [2, 3, 1], 'int32');
+    expectArraysClose(
+        await tf.notEqual(a, b).data(), [0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1]);
+  });
+  it('broadcasting Tensor3D shapes - float32', async () => {
+    const a = tf.tensor3d(
+        [
+          [[1.1, 0.1], [2.1, 3.1], [4.1, 5.1]],
+          [[6.1, 7.1], [9.1, 8.1], [10.1, 11.1]]
+        ],
+        [2, 3, 2], 'float32');
+    const b = tf.tensor3d(
+        [[[1.1], [2.1], [3.1]], [[7.1], [10.1], [9.1]]], [2, 3, 1], 'float32');
+    expectArraysClose(
+        await tf.notEqual(a, b).data(), [0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1]);
+  });
+  it('NaNs in Tensor3D - float32', async () => {
+    const a = tf.tensor3d(
+        [[[1.1], [NaN], [1.1]], [[0.1], [0.1], [0.1]]], [2, 3, 1], 'float32');
+    const b = tf.tensor3d(
+        [[[0.1], [0.1], [1.1]], [[1.1], [0.1], [NaN]]], [2, 3, 1], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0, 1, 0, 1]);
+  });
+  it('3D and scalar', async () => {
+    const a = tf.tensor3d([1, 2, 3, 4, 5, -1], [2, 3, 1]);
+    const b = tf.scalar(-1);
+    const res = tf.notEqual(a, b);
+    expect(res.dtype).toBe('bool');
+    expect(res.shape).toEqual([2, 3, 1]);
+    expectArraysEqual(await res.data(), [1, 1, 1, 1, 1, 0]);
+  });
+
+  // Tensor4D:
+  it('Tensor4D - int32', async () => {
+    let a = tf.tensor4d([1, 4, 5, 8], [2, 2, 1, 1], 'int32');
+    let b = tf.tensor4d([2, 3, 6, 8], [2, 2, 1, 1], 'int32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 0]);
+
+    a = tf.tensor4d([0, 1, 2, 3], [2, 2, 1, 1], 'int32');
+    b = tf.tensor4d([0, 1, 2, 3], [2, 2, 1, 1], 'int32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0, 0]);
+
+    a = tf.tensor4d([1, 1, 1, 1], [2, 2, 1, 1], 'int32');
+    b = tf.tensor4d([2, 2, 2, 2], [2, 2, 1, 1], 'int32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 1]);
+  });
+  it('Tensor4D - float32', async () => {
+    let a = tf.tensor4d([1.1, 4.1, 5.1, 8.1], [2, 2, 1, 1], 'float32');
+    let b = tf.tensor4d([2.1, 3.1, 6.1, 8.1], [2, 2, 1, 1], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 0]);
+
+    a = tf.tensor4d([0.1, 1.1, 2.2, 3.3], [2, 2, 1, 1], 'float32');
+    b = tf.tensor4d([0.1, 1.1, 2.2, 3.3], [2, 2, 1, 1], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [0, 0, 0, 0]);
+
+    a = tf.tensor4d([0.1, 0.1, 0.1, 0.1], [2, 2, 1, 1], 'float32');
+    b = tf.tensor4d([1.1, 1.1, 1.1, 1.1], [2, 2, 1, 1], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 1, 1]);
+  });
+  it('broadcasting Tensor4D shapes - int32', async () => {
+    const a = tf.tensor4d([1, 2, 5, 9], [2, 2, 1, 1], 'int32');
+    const b = tf.tensor4d(
+        [[[[1, 2]], [[3, 4]]], [[[5, 6]], [[7, 8]]]], [2, 2, 1, 2], 'int32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [0, 1, 1, 1, 0, 1, 1, 1]);
+  });
+  it('broadcasting Tensor4D shapes - float32', async () => {
+    const a = tf.tensor4d([1.1, 2.1, 5.1, 9.1], [2, 2, 1, 1], 'float32');
+    const b = tf.tensor4d(
+        [[[[1.1, 2.1]], [[3.1, 4.1]]], [[[5.1, 6.1]], [[7.1, 8.1]]]],
+        [2, 2, 1, 2], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [0, 1, 1, 1, 0, 1, 1, 1]);
+  });
+  it('NaNs in Tensor4D - float32', async () => {
+    const a = tf.tensor4d([1.1, NaN, 1.1, 0.1], [2, 2, 1, 1], 'float32');
+    const b = tf.tensor4d([0.1, 1.1, 1.1, NaN], [2, 2, 1, 1], 'float32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0, 1]);
+  });
+
+  it('throws when passed a as a non-tensor', () => {
+    expect(() => tf.notEqual({} as tf.Tensor, tf.scalar(1)))
+        .toThrowError(/Argument 'a' passed to 'notEqual' must be a Tensor/);
+  });
+  it('throws when passed b as a non-tensor', () => {
+    expect(() => tf.notEqual(tf.scalar(1), {} as tf.Tensor))
+        .toThrowError(/Argument 'b' passed to 'notEqual' must be a Tensor/);
+  });
+
+  it('accepts a tensor-like object', async () => {
+    const a = tf.tensor1d([1, 4, 5], 'int32');
+    const b = tf.tensor1d([2, 3, 5], 'int32');
+    expectArraysClose(await tf.notEqual(a, b).data(), [1, 1, 0]);
+  });
+});
diff --git a/tfjs-core/src/ops/ops.ts b/tfjs-core/src/ops/ops.ts
index 8dced31b20c..00237b3052d 100644
--- a/tfjs-core/src/ops/ops.ts
+++ b/tfjs-core/src/ops/ops.ts
@@ -28,6 +28,7 @@ export {div} from './div';
 export {divNoNan} from './div_no_nan';
 export {eye} from './eye';
 export {multinomial} from './multinomial';
+export {notEqual} from './not_equal';
 export {oneHot} from './one_hot';
 export {pad} from './pad';
 export {pad1d} from './pad1d';
diff --git a/tfjs-core/src/public/chained_ops/not_equal.ts b/tfjs-core/src/public/chained_ops/not_equal.ts
new file mode 100644
index 00000000000..08fc8114419
--- /dev/null
+++ b/tfjs-core/src/public/chained_ops/not_equal.ts
@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC. 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 {notEqual} from '../../ops/not_equal';
+import {Tensor} from '../../tensor';
+import {Rank, TensorLike} from '../../types';
+
+declare module '../../tensor' {
+  interface Tensor<R extends Rank = Rank> {
+    notEqual<T extends Tensor>(b: Tensor|TensorLike): T;
+  }
+}
+
+Tensor.prototype.notEqual = function<T extends Tensor>(b: Tensor|
+                                                       TensorLike): T {
+  this.throwIfDisposed();
+  return notEqual(this, b);
+};
diff --git a/tfjs-core/src/public/chained_ops/register_all_chained_ops.ts b/tfjs-core/src/public/chained_ops/register_all_chained_ops.ts
index 1e46d1a6ca6..6381adc4449 100644
--- a/tfjs-core/src/public/chained_ops/register_all_chained_ops.ts
+++ b/tfjs-core/src/public/chained_ops/register_all_chained_ops.ts
@@ -20,6 +20,7 @@ import './broadcast_to';
 import './div';
 import './div_no_nan';
 import './one_hot';
+import './not_equal';
 import './pad';
 import './squared_difference';
 import './sub';
diff --git a/tfjs-core/src/public/chained_ops/register_all_chained_ops_test.ts b/tfjs-core/src/public/chained_ops/register_all_chained_ops_test.ts
index f6b03ee34a1..e9175206785 100644
--- a/tfjs-core/src/public/chained_ops/register_all_chained_ops_test.ts
+++ b/tfjs-core/src/public/chained_ops/register_all_chained_ops_test.ts
@@ -24,8 +24,8 @@ import {ALL_ENVS, describeWithFlags} from '../../jasmine_util';
 // flexibility to change in future.
 
 const CHAINED_OPS = [
-  'add', 'batchNorm', 'broadcastTo', 'div', 'divNoNan', 'oneHot', 'pad',
-  'square', 'sub', 'tile', 'transpose'
+  'add', 'batchNorm', 'broadcastTo', 'div', 'divNoNan', 'oneHot', 'notEqual',
+  'pad', 'square', 'sub', 'tile', 'transpose'
 ];
 
 describeWithFlags('chained ops', ALL_ENVS, () => {
diff --git a/tfjs-core/src/tensor.ts b/tfjs-core/src/tensor.ts
index b184b0eaf49..3759a3e8233 100644
--- a/tfjs-core/src/tensor.ts
+++ b/tfjs-core/src/tensor.ts
@@ -230,7 +230,6 @@ export interface OpHandler {
   logicalXor<T extends Tensor>(a: Tensor, b: Tensor|TensorLike): T;
   where<T extends Tensor>(condition: Tensor|TensorLike, a: T, b: T|TensorLike):
       T;
-  notEqual<T extends Tensor>(a: Tensor, b: Tensor|TensorLike): T;
   notEqualStrict<T extends Tensor>(a: T, b: T|TensorLike): T;
   less<T extends Tensor>(a: Tensor, b: Tensor|TensorLike): T;
   lessStrict<T extends Tensor>(a: T, b: T|TensorLike): T;
@@ -941,11 +940,6 @@ export class Tensor<R extends Rank = Rank> {
   }
 
   // Compare ops.
-
-  notEqual<T extends Tensor>(x: Tensor|TensorLike): T {
-    this.throwIfDisposed();
-    return opHandler.notEqual(this, x);
-  }
   notEqualStrict<T extends this>(this: T, x: T|TensorLike): T {
     this.throwIfDisposed();
     return opHandler.notEqualStrict(this, x);
diff --git a/tfjs-core/src/tests.ts b/tfjs-core/src/tests.ts
index ec2962598b7..4aa3b5d4c87 100644
--- a/tfjs-core/src/tests.ts
+++ b/tfjs-core/src/tests.ts
@@ -78,6 +78,7 @@ import './ops/lstm_test';
 import './ops/matmul_test';
 import './ops/moving_average_test';
 import './ops/multinomial_test';
+import './ops/not_equal_test';
 import './ops/one_hot_test';
 import './ops/operation_test';
 import './ops/pad_test';