tfjs 🚀 - Intel GPU support for Celeron/Baytrail

cc @nsthorat @dsmilkov for comments.

caisq on 12 Jul 2018

Looks like some math operations are departing from the expected result. Unfortunately, we don't have an Intel gpu at the moment, but if anyone has one and is interested in helping, we are happy to share pointers for how to debug.

dsmilkov on 13 Jul 2018

@dsmilkov I'll give it a go, it became an issue for me since I can't warn my users if the site won't work

seranus on 18 Jul 2018

@dsmilkov karma failed tests output on latest tfjs-core build

Chrome 67.0.3396 (Linux 0.0.0) gramSchmidt-non-tiny test-webgl2 {"WEBGL_VERSION":2} 32x512 FAILED
Error: Arrays differ: actual[0] = 0.9943403601646423, expected[0] = 1.
at
at Object.expectArraysClose (src/test_util.ts:95:12 <- src/test_util.js:68:19)
at UserContext. (src/ops/linalg_ops_test.ts:93:4 <- src/ops/linalg_ops_test.js:56:21)
at

Chrome 67.0.3396 (Linux 0.0.0) transpose test-webgl1 {"WEBGL_VERSION":1} 5D [r, c, d, e, f] => [r, c, f, e, d] FAILED
Error: Arrays differ: actual[1] = 1, expected[1] = 3.
at
at Object.expectArraysClose (src/test_util.ts:95:12 <- src/test_util.js:68:19)
at UserContext. (src/ops/transpose_test.ts:89:4 <- src/ops/transpose_test.js:58:21)
at

Chrome 67.0.3396 (Linux 0.0.0) transpose test-webgl2 {"WEBGL_VERSION":2} 5D [r, c, d, e, f] => [r, c, f, e, d] FAILED
Error: Arrays differ: actual[1] = 1, expected[1] = 3.
at
at Object.expectArraysClose (src/test_util.ts:95:12 <- src/test_util.js:68:19)
at UserContext. (src/ops/transpose_test.ts:89:4 <- src/ops/transpose_test.js:58:21)
at

Chrome 67.0.3396 (Linux 0.0.0) tan test-webgl1 {"WEBGL_VERSION":1} gradients: Tensor1D FAILED
Error: Arrays differ: actual[3] = 49.71051788330078, expected[3] = 49.71152682983342.
at
at Object.expectArraysClose (src/test_util.ts:95:12 <- src/test_util.js:68:19)
at UserContext. (src/ops/unary_ops_test.ts:1586:4 <- src/ops/unary_ops_test.js:1190:21)
at

Chrome 67.0.3396 (Linux 0.0.0) tan test-webgl2 {"WEBGL_VERSION":2} gradients: Tensor1D FAILED
Error: Arrays differ: actual[3] = 49.71051788330078, expected[3] = 49.71152682983342.
at
at Object.expectArraysClose (src/test_util.ts:95:12 <- src/test_util.js:68:19)
at UserContext. (src/ops/unary_ops_test.ts:1586:4 <- src/ops/unary_ops_test.js:1190:21)
at

Test on an earlier version also reported

Chrome 67.0.3396 (Linux 0.0.0) gramSchmidt-non-tiny test-webgl1 {"WEBGL_VERSION":1} 32x512 FAILED
Error: Arrays differ: actual[0] = 0.9793801307678223, expected[0] = 1.
at
at Object.expectArraysClose (src/test_util.ts:95:12 <- src/test_util.js:68:19)
at UserContext. (src/ops/linalg_ops_test.ts:93:4 <- src/ops/linalg_ops_test.js:56:21)
at
Chrome 67.0.3396 (Linux 0.0.0): Executed 3398 of 7053 (1 FAILED) (0 secs / 46.76Chrome 67.0.3396 (Linux 0.0.0) SLOW 3.012 secs: gramSchmidt-non-tiny test-webgl1 {"WEBGL_VERSION":1} 32x512

seranus on 19 Jul 2018

@dsmilkov karma failed tests output on latest tfjs-core build

Chrome 67.0.3396 (Linux 0.0.0) gramSchmidt-non-tiny test-webgl2 {"WEBGL_VERSION":2} 32x512 FAILED
Error: Arrays differ: actual[0] = 0.9943403601646423, expected[0] = 1.
at
at Object.expectArraysClose (src/test_util.ts:95:12 <- src/test_util.js:68:19)
at UserContext. (src/ops/linalg_ops_test.ts:93:4 <- src/ops/linalg_ops_test.js:56:21)
at

Chrome 67.0.3396 (Linux 0.0.0) transpose test-webgl1 {"WEBGL_VERSION":1} 5D [r, c, d, e, f] => [r, c, f, e, d] FAILED
Error: Arrays differ: actual[1] = 1, expected[1] = 3.
at
at Object.expectArraysClose (src/test_util.ts:95:12 <- src/test_util.js:68:19)
at UserContext. (src/ops/transpose_test.ts:89:4 <- src/ops/transpose_test.js:58:21)
at

Chrome 67.0.3396 (Linux 0.0.0) transpose test-webgl2 {"WEBGL_VERSION":2} 5D [r, c, d, e, f] => [r, c, f, e, d] FAILED
Error: Arrays differ: actual[1] = 1, expected[1] = 3.
at
at Object.expectArraysClose (src/test_util.ts:95:12 <- src/test_util.js:68:19)
at UserContext. (src/ops/transpose_test.ts:89:4 <- src/ops/transpose_test.js:58:21)
at

Chrome 67.0.3396 (Linux 0.0.0) tan test-webgl1 {"WEBGL_VERSION":1} gradients: Tensor1D FAILED
Error: Arrays differ: actual[3] = 49.71051788330078, expected[3] = 49.71152682983342.
at
at Object.expectArraysClose (src/test_util.ts:95:12 <- src/test_util.js:68:19)
at UserContext. (src/ops/unary_ops_test.ts:1586:4 <- src/ops/unary_ops_test.js:1190:21)
at

Chrome 67.0.3396 (Linux 0.0.0) tan test-webgl2 {"WEBGL_VERSION":2} gradients: Tensor1D FAILED
Error: Arrays differ: actual[3] = 49.71051788330078, expected[3] = 49.71152682983342.
at
at Object.expectArraysClose (src/test_util.ts:95:12 <- src/test_util.js:68:19)
at UserContext. (src/ops/unary_ops_test.ts:1586:4 <- src/ops/unary_ops_test.js:1190:21)
at

Test on an earlier version also reported

Chrome 67.0.3396 (Linux 0.0.0) gramSchmidt-non-tiny test-webgl1 {"WEBGL_VERSION":1} 32x512 FAILED
Error: Arrays differ: actual[0] = 0.9793801307678223, expected[0] = 1.
at
at Object.expectArraysClose (src/test_util.ts:95:12 <- src/test_util.js:68:19)
at UserContext. (src/ops/linalg_ops_test.ts:93:4 <- src/ops/linalg_ops_test.js:56:21)
at
Chrome 67.0.3396 (Linux 0.0.0): Executed 3398 of 7053 (1 FAILED) (0 secs / 46.76Chrome 67.0.3396 (Linux 0.0.0) SLOW 3.012 secs: gramSchmidt-non-tiny test-webgl1 {"WEBGL_VERSION":1} 32x512

From the above, I think the problem may be related to precision. The actual precision of Intel GPU may be worse than 5/1000.

I am an Intel GPU user.
I think this issue is critical to me and other Intel GPU users.
Without fixing this issue, TensorFlow.js is almost unusable.

xianrenb on 6 Jan 2019

👍1

Current version of TensorFlow.js is still not usable for my Intel GPU based system.
Previously, I tested various versions of tfjs-core, and found something between version 0.13.2 and 0.13.3 caused my program not working correctly.
The most probable one is https://github.com/tensorflow/tfjs-core/commit/5a4c4fd99eacfee454222e080d5cd422b61265f1 .
It seems that calculation in the mentioned commit requires high precision which is not available in (some) Intel GPU.
Perhaps this information is useful for fixing this issue.

xianrenb on 10 Feb 2019

Perhaps it is an issue of ANGLE (Almost Native Graphics Layer Engine).
There are many related bugs, e.g., https://www.shadertoy.com/view/MdtfWN.

xianrenb on 11 Feb 2019

@xianrenb thanks for all the great pointers. Our team recently acquired some Windows machines with Intel GPUs.

First, I'd love to know if you still have numerical issues using the latest [email protected]. If yes, can you send us an up-to-date instructions on how to reproduce the problem. Thank you so much!

dsmilkov on 25 Mar 2019

@dsmilkov karma failed tests on latest tfjs-core, partial output:

Chrome 73.0.3683 (Windows 10.0.0) div webgl1 {"WEBGL_VERSION":1,"WEBGL_CPU_FORWARD":false,"WEBGL_SIZE_UPLOAD_UNIFORM":0} integer division broadcasts FAILED
Error: Failed to link vertex and fragment shaders.
at Object.linkProgram (src/kernels/webgl/webgl_util.ts:156:10 <- src/kernels/webgl/webgl_util.js:127:15)
at GPGPUContext.createProgram (src/kernels/webgl/gpgpu_context.ts:296:15 <- src/kernels/webgl/gpgpu_context.js:234:20)
at Object.compileProgram (src/kernels/webgl/gpgpu_math.ts:86:29 <- src/kernels/webgl/gpgpu_math.js:47:30)
at src/kernels/backend_webgl.ts:2333:24 <- src/kernels/backend_webgl.js:1873:31
at MathBackendWebGL.getAndSaveBinary (src/kernels/backend_webgl.ts:2372:30 <- src/kernels/backend_webgl.js:1903:37)
at MathBackendWebGL.compileAndRun (src/kernels/backend_webgl.ts:2332:24 <- src/kernels/backend_webgl.js:1872:27)
at MathBackendWebGL.packedBinaryOp (src/kernels/backend_webgl.ts:1400:16 <- src/kernels/backend_webgl.js:1168:21)
at MathBackendWebGL.floorDiv (src/kernels/backend_webgl.ts:1370:18 <- src/kernels/backend_webgl.js:1144:25)
at environment_1.ENV.engine.runKernel.$a (src/ops/binary_ops.ts:494:24 <- src/ops/binary_ops.js:460:27)
at src/engine.ts:227:17 <- src/engine.js:171:26
at Engine.scopedRun (src/engine.ts:172:19 <- src/engine.js:126:23)
at Engine.runKernel (src/engine.ts:225:9 <- src/engine.js:169:14)
at floorDiv_ (src/ops/binary_ops.ts:493:20 <- src/ops/binary_ops.js:459:37)
at Object.floorDiv (src/ops/operation.ts:46:23 <- src/ops/operation.js:46:29)
at div_ (src/ops/binary_ops.ts:406:11 <- src/ops/binary_ops.js:377:24)
at Object.div (src/ops/operation.ts:46:23 <- src/ops/operation.js:46:29)
at UserContext. (src/ops/arithmetic_test.ts:66:17 <- src/ops/arithmetic_test.js:53:20)
at
.........................

Chrome 73.0.3683 (Windows 10.0.0) localResponseNormalization with Tensor4D webgl1 {"WEBGL_VERSION":1,"WEBGL_CPU_FORWARD":false,"WEBGL_SIZE_UPLOAD_UNIFORM":0} gradient with 4D input FAILED
Error: Arrays differ: actual[3] = 0.33881255984306335, expected[3] = 0.09561057.
at
at expectArraysPredicate (src/test_util.ts:112:12 <- src/test_util.js:96:19)
at Object.expectArraysClose (src/test_util.ts:57:9 <- src/test_util.js:50:12)
at UserContext. (src/ops/lrn_test.ts:971:4 <- src/ops/lrn_test.js:898:21)
at
......

Chrome 73.0.3683 (Windows 10.0.0) localResponseNormalization with Tensor4D webgl2 {"WEBGL_VERSION":2,"WEBGL_CPU_FORWARD":false,"WEBGL_SIZE_UPLOAD_UNIFORM":0} gradient with 4D input FAILED
Error: Arrays differ: actual[3] = 0.33881255984306335, expected[3] = 0.09561057.
at
at expectArraysPredicate (src/test_util.ts:112:12 <- src/test_util.js:96:19)
at Object.expectArraysClose (src/test_util.ts:57:9 <- src/test_util.js:50:12)
at UserContext. (src/ops/lrn_test.ts:971:4 <- src/ops/lrn_test.js:898:21)
at
.........

Chrome 73.0.3683 (Windows 10.0.0) matmul webgl-only webgl1 {"WEBGL_VERSION":1,"WEBGL_CPU_FORWARD":false,"WEBGL_SIZE_UPLOAD_UNIFORM":0} Matrix times vector, large matrix FAILED
Error: Arrays differ: actual[0] = 0, expected[0] = 2.
at
at expectArraysPredicate (src/test_util.ts:112:12 <- src/test_util.js:96:19)
at Object.expectArraysClose (src/test_util.ts:57:9 <- src/test_util.js:50:12)
at UserContext. (src/ops/matmul_test.ts:1264:4 <- src/ops/matmul_test.js:1088:21)
at

Chrome 73.0.3683 (Windows 10.0.0) matmul webgl-only webgl2 {"WEBGL_VERSION":2,"WEBGL_CPU_FORWARD":false,"WEBGL_SIZE_UPLOAD_UNIFORM":0} Matrix times vector, large matrix FAILED
Error: Arrays differ: actual[0] = 0, expected[0] = 2.
at
at expectArraysPredicate (src/test_util.ts:112:12 <- src/test_util.js:96:19)
at Object.expectArraysClose (src/test_util.ts:57:9 <- src/test_util.js:50:12)
at UserContext. (src/ops/matmul_test.ts:1264:4 <- src/ops/matmul_test.js:1088:21)
at

Chrome 73.0.3683 (Windows 10.0.0) 1D IFFT webgl1 {"WEBGL_VERSION":1,"WEBGL_CPU_FORWARD":false,"WEBGL_SIZE_UPLOAD_UNIFORM":0} should return the same value with TensorFlow (2 elements) FAILED
Error: Arrays differ: actual[0] = 0, expected[0] = 1.5.
at
at expectArraysPredicate (src/test_util.ts:112:12 <- src/test_util.js:96:19)
at Object.expectArraysClose (src/test_util.ts:57:9 <- src/test_util.js:50:12)
at UserContext. (src/ops/spectral_ops_test.ts:107:4 <- src/ops/spectral_ops_test.js:90:21)
at

Chrome 73.0.3683 (Windows 10.0.0) step webgl1 {"WEBGL_VERSION":1,"WEBGL_CPU_FORWARD":false,"WEBGL_SIZE_UPLOAD_UNIFORM":0} with 1d tensor and alpha FAILED
Error: Arrays differ: actual[4] = 0.10000000149011612, expected[4] = NaN.
at
at expectArraysPredicate (src/test_util.ts:112:12 <- src/test_util.js:96:19)
at Object.expectArraysClose (src/test_util.ts:57:9 <- src/test_util.js:50:12)
at UserContext. (src/ops/unary_ops_test.ts:303:4 <- src/ops/unary_ops_test.js:248:21)
at
.

Chrome 73.0.3683 (Windows 10.0.0) tan webgl1 {"WEBGL_VERSION":1,"WEBGL_CPU_FORWARD":false,"WEBGL_SIZE_UPLOAD_UNIFORM":0} gradients: Tensor1D FAILED
Error: Arrays differ: actual[3] = 49.71051788330078, expected[3] = 49.71152682983342.
at
at expectArraysPredicate (src/test_util.ts:112:12 <- src/test_util.js:96:19)
at Object.expectArraysClose (src/test_util.ts:57:9 <- src/test_util.js:50:12)
at UserContext. (src/ops/unary_ops_test.ts:2149:4 <- src/ops/unary_ops_test.js:1639:21)
at
........

Chrome 73.0.3683 (Windows 10.0.0) tan webgl2 {"WEBGL_VERSION":2,"WEBGL_CPU_FORWARD":false,"WEBGL_SIZE_UPLOAD_UNIFORM":0} gradients: Tensor1D FAILED
Error: Arrays differ: actual[3] = 49.71051788330078, expected[3] = 49.71152682983342.
at
at expectArraysPredicate (src/test_util.ts:112:12 <- src/test_util.js:96:19)
at Object.expectArraysClose (src/test_util.ts:57:9 <- src/test_util.js:50:12)
at UserContext. (src/ops/unary_ops_test.ts:2149:4 <- src/ops/unary_ops_test.js:1639:21)
at
.....................................................................

Chrome 73.0.3683 (Windows 10.0.0) atan webgl1 {"WEBGL_VERSION":1,"WEBGL_CPU_FORWARD":false,"WEBGL_SIZE_UPLOAD_UNIFORM":0} propagates NaNs FAILED
Error: Arrays differ: actual[1] = 0.7854096293449402, expected[1] = NaN.
at
at expectArraysPredicate (src/test_util.ts:112:12 <- src/test_util.js:96:19)
at Object.expectArraysClose (src/test_util.ts:57:9 <- src/test_util.js:50:12)
at UserContext. (src/ops/unary_ops_test.ts:2419:4 <- src/ops/unary_ops_test.js:1854:21)
at
.........

Chrome 73.0.3683 (Windows 10.0.0): Executed 9643 of 9661 (70 FAILED) (skipped 18) (6 mins 56.373 secs / 6 mins 42.685 secs)

xianrenb on 26 Mar 2019

Hi @xianrenb that is very interesting and helpful. We have a windows laptop and only 9 unit tests are failing here (which we are in the process of fixing). However I noticed that your machine has 70 failing and many more numerical issues.

I have a few asks if you don't mind:

I undid the relevant changes in https://github.com/tensorflow/tfjs-core/commit/5a4c4fd99eacfee454222e080d5cd422b61265f1 and commited them to the win_index branch. Can you check out that branch and see if the same number of unit tests are failing.
Can you share the output of tf.abs(1e-8).abs().print() (note the double abs)
Can you send us your machine specs (laptop/desktop? graphic card, cpu). We might buy the same machine and use it for future testing.
If you don't mind, can you take a screenshot of https://js.tensorflow.org/debug/ and of http://webglreport.com/?v=2 and share it with us

Thank you so much!

dsmilkov on 27 Mar 2019

@dsmilkov , tested the win_index branch, and it changed to 68 failing.
I think there are two main causes for the failed tests.

The NaN problem.
https://stackoverflow.com/questions/37532640/making-a-nan-on-purpose-in-webgl

The special values Inf and −Inf encode values with magnitudes too large to be represented; the special value NaN encodes “Not A Number” values resulting from undefined arithmetic operations such as 0/0. Implementations are permitted, but not required, to support Inf's and NaN's in their floating-point computations.

I guess my GPU simply does not support Inf/NaN. I would suggest tfjs to automatically detect whether the GPU supports Inf/NaN or not, and skips related tests if it finds GPU does not support Inf/NaN.

Meanwhile, in https://github.com/tensorflow/tfjs-core/blob/master/src/kernels/webgl/glsl_version.ts

defineSpecialNaN = `
      const float NAN = uintBitsToFloat(uint(0x7fc00000));
    `;

but in https://en.wikipedia.org/wiki/Single-precision_floating-point_format

x 11111111 100000000000000000000012 = ffc0 0001 16 = qNaN (on x86 and ARM processors)
x 11111111 000000000000000000000012 = ff80 0001 16 = sNaN (on x86 and ARM processors)

The floor bug of ANGLE
In https://github.com/tensorflow/tfjs-core/blob/master/src/kernels/webgl/shader_compiler.ts, there are many round() used. But round() is implemented using floor(). Therefore, I believe it may not be accurate all the time. Any index calculation should depend on integer calculation instead of using floating-point number calculation.

And, below are some more info about my machine detected using https://js.tensorflow.org/debug/:

navigator.userAgent:
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36"

tf.ENV.features:
{
"DEBUG": false,
"IS_BROWSER": true,
"WEBGL_VERSION": 2,
"BACKEND": "webgl",
"WEBGL_RENDER_FLOAT32_ENABLED": true,
"WEBGL_SIZE_UPLOAD_UNIFORM": 4,
"WEBGL_MAX_TEXTURE_SIZE": 16384,
"PROD": false,
"WEBGL_NUM_MB_BEFORE_PAGING": 614700,
"WEBGL_PACK": true,
"WEBGL_LAZILY_UNPACK": true,
"WEBGL_DOWNLOAD_FLOAT_ENABLED": true,
"WEBGL_FENCE_API_ENABLED": true
}

tf.scalar(2).square():
4

tf.scalar(2.4).square():
5.760000228881836

from console:
tf.abs(1e-8).abs().print() tfjs@latest:2 Tensor 9.99999993922529e-9 undefined

Thank you.

xianrenb on 28 Mar 2019

Thanks. This is all very helpful. Can you re-run the unit tests using the master branch of tfjs-core. We did a few fixes related to windows.

Also what would be helpful is to share your Intel CPU chip (e.g Haswell, Broadwell, Skywell or Coffeelake). We suspect you might be on Haswell, which is the last remaining chipset where we are observing numerical problems.

dsmilkov on 10 Apr 2019

@dsmilkov , tested the master branch, and it changed to 54 failed.

My Intel CPU chip is an Intel Celeron Processor N2840. It is a Silvermont chip.

xianrenb on 11 Apr 2019

Celeron N2840 is Baytrail platform (small core, and its related big core platform is Ivybridge), where the integrated GPU is Gen7. Haswell came right after Ivybridge and baytrail, and the integrated GPU inside Haswell is Gen7.5. According to our tests, we got 2 failures on Haswell (GPU Gen7.5), 1 failure on Broadwell (GPU Gen8), and no failure on Skylake/Kabylake/Coffeelake (GPU Gen9).
You may find more details of GPU info at https://en.wikipedia.org/wiki/List_of_Intel_graphics_processing_units.

gyagp on 11 Apr 2019

I know that it may not be worthwhile to put extra effort for supporting older GPUs.
How about adding code for auto-detecting the problem when loading tfjs, and automatically setting default backend to CPU backend if any is found?

xianrenb on 31 Jul 2019

👍1

That's a good suggestion in theory but since the browser runs in a sandbox, I don't think we are able to access the hardware info.

dsmilkov on 31 Jul 2019

Adding code for checking whether the GPU could support NaN or with high enough precision should be simple. In fact, these should probably be the real reasons why recent tfjs code would fail with older GPUs. The exact hardware GPU type is not important.

xianrenb on 1 Aug 2019

It should be noted that developer could choose backend for their application, but normal user using their application with older GPU could not.

xianrenb on 1 Aug 2019

I would like to share some info below which may be useful.
According to https://en.wikipedia.org/wiki/Half-precision_floating-point_format:
Precision limitations on decimal values in [1, 2048]:
Decimals between 1024 and 2048: fixed interval 2^0.
Precision limitations on integer values:
Integers between 2048 and 4096 round to a multiple of 2.

The problem is even worse for bigger numbers.

On the other hand,
https://github.com/tensorflow/tfjs/blob/8c2d9e05643988fa7f4575c30a5ad3e732d189b2/tfjs-core/src/backends/webgl/shader_compiler.ts defines:
const vec2 halfCR = vec2(0.5, 0.5);
and do something like return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);, which may get incorrect result for GPU without enough precision.

xianrenb on 9 Sep 2019

Seems like it is possible to get GPU vendor/renderer with code:
https://gist.github.com/cvan/042b2448fcecefafbb6a91469484cdf8
Which gets info like this:
"Intel Open Source Technology Center", "Mesa DRI Intel(R) Haswell Desktop "
So it is useful to at least show a warning.
I've tried to switch (based on vendor) to CPU backend for Intel, but tfjs failed to produce correct results with my model (densenet-like conv2d with large filters and dilations + batchNorm + relu)

F0REacH on 9 Sep 2019

Is it possible to use texelFetch() instead, which takes ivec texCoord?
https://www.khronos.org/opengl/wiki/Sampler_(GLSL)

xianrenb on 9 Sep 2019

After playing around in "shadertoy.com", I think the main problem is not precision.
However, in the comments of https://www.shadertoy.com/view/XdsSRN states:

My understanding is that GLSL*, and possibly Cuda 6 by default, are not doing IEEE754 math, so that x/x can be != 1 for x = integer encoded as float. This impacts divisions as well as functions like mod, for all fractions that should give an integer.

And the page shows the following code:

// the safe mod function:
float trueMod(float x, float y)  { 
    float s; if (y>=0.) s=1.; else { x=-x; y=-y; s=-1.; } 
    float v = x - y*float(int(x)/int(y)); 
    return (v>=0.) ? s*v : s*(v+y); 
}

On the other hand,
https://github.com/tensorflow/tfjs/blob/8c2d9e05643988fa7f4575c30a5ad3e732d189b2/tfjs-core/src/backends/webgl/glsl_version.ts

defineRound = `
      #define round(value) newRound(value)
      int newRound(float value) {
        return int(floor(value + 0.5));
      }
      ivec4 newRound(vec4 value) {
        return ivec4(floor(value + vec4(0.5)));
      }
    `;

and
https://github.com/tensorflow/tfjs/blob/8c2d9e05643988fa7f4575c30a5ad3e732d189b2/tfjs-core/src/backends/webgl/shader_compiler.ts

vec2 modCoord = mod(innerDims, 2.);

seem not ok.
There may be similar problem elsewhere.

xianrenb on 10 Sep 2019

One may implement floor() using mod():
mod(x, y) = x - y * floor(x/y),
so,
mod(x, 1) = x - 1 * floor(x/1), or
floor(x) = x - mod(x, 1)

xianrenb on 10 Sep 2019

I believe that the floor() bug should have been fixed in ANGLE, so it is unrelated to the problem.

I found that either my GPU is reporting wrong max texture size, or it does not work correctly when max texture size is used.
I tried to add the following code and it works for me:
const maxTextureSize = tf.ENV.getNumber('WEBGL_MAX_TEXTURE_SIZE') / 2; tf.ENV.set('WEBGL_MAX_TEXTURE_SIZE', maxTextureSize);

xianrenb on 5 Oct 2019

👍1

xianrenb on 5 Oct 2019

Downloading libtensorflow Error: Unsupported system: gpu-linux-arm

git-chenjiqing on 3 Jan 2020

👀1 🚀1

@git-chenjiqing the library does not support arm cpu. You can try to compile the libtensorflow from scratch following this instruction: https://github.com/tensorflow/tfjs/tree/master/tfjs-node#optional-build-optimal-tensorflow-from-source

kangyizhang on 3 Jan 2020

Automatically closing due to lack of recent activity. Please update the issue when new information becomes available, and we will reopen the issue. Thanks!

rthadur on 18 Jan 2020

@rthadur this is a labeled P2 bug, I don't think it could be closed due to lack of recent activity.

xianrenb on 18 Jan 2020

Tfjs: Intel GPU support for Celeron/Baytrail

All 29 comments

Related issues