Is there a version of TensorFlow not compiled for AVX instructions?

mac your cpu supports instructions that this tensorflow binary was not compiled to use: avx2 fma
compile tensorflow cpu
tensorflow compiling from source
install older version of tensorflow
build tensorflow from source
tensorflow versions
d_glibcxx_use_cxx11_abi tensorflow
tensorflow build from scratch

I'm trying to get TensorFlow up on my Chromebook, not the best place, I know, but I just want to get a feel for it. I haven't done much work in the Python dev environment, or in any dev environment for that matter, so bear with me. After figuring out pip, I installed TensorFlow and tried to import it, receiving this error:

Python 3.5.2 (default, Nov 23 2017, 16:37:01) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow as tf
2018-12-11 06:09:54.960546: F tensorflow/core/platform/cpu_feature_guard.cc:37] The TensorFlow library was compiled to use AVX instructions, but these aren't available on your machine.
Aborted (core dumped)

After some research, I have discovered that my processor (an Intel Celeron N2840 (Bay Trail-M Architecture)) does not support AVX instructions, so I was wondering if there was a way to use a version compiled for some other instruction set. Cog tells me I can use MMX and various SSEs (whatever the hell that means).

P.S. This is sort of a duplicate of TensorFlow error using AVX instructions on Linux while working on Windows on the same machine but not entirely. Plus I can't comment because I don't have 50 reputation.

P.P.S. I looked at How to compile Tensorflow with SSE4.2 and AVX instructions? and got scared

A best practices approach suggested by peter-cordes is to see what gcc is going to make of your 'what capabilities your cpu has' by issuing the following:

gcc -O3 -fverbose-asm -march=native -xc /dev/null -S -o- | less

This command will provide information (all) about your cpu capabilities from the view of gcc, whom is going to do the build, so gcc's view matters.

When does this come up? When a program offers to tailor itself to your cpu. Dang. What do I know about my cpu. Well, the above line will tell you all you need to know.

That said, generally, people/developers that are promoting cpu based capabilities will state or suggest a list of things that go faster/better/stronger if your cpu has *. And the above will give you *. Read carefully what you see. If you don't have it, you don't want it, i.e.

-mno-avx(whatever you don't want;in my case it was avx)

A good overview of install of CPU capable on older cpu(s) is provided by Mikael Fernandez Simalango for Ubuntu 16.04 LTS. It assumes a python2.7 environ but easily translates to python3. The heart of the matter is extracting which cpu instruction extensions are available on your particular cpu that will be used in addition to -march=native via /proc/cpuinfo, (but note, it appears limited to what flags it accepts, so may be better to actually read through the instruction above and reflect)

grep flags -m1 /proc/cpuinfo | cut -d ":" -f 2 | tr '[:upper:]' 
'[:lower:]' | { read FLAGS; OPT="-march=native"; for flag in $FLAGS; 
do case "$flag" in "sse4_1" | "sse4_2" | "ssse3" | "fma" | "cx16" | 
"popcnt" | "avx" | "avx2") OPT+=" -m$flag";; esac; done; 
MODOPT=${OPT//_/\.}; echo "$MODOPT"; }

Running this on my old box output:

-march=native -mssse3 -mcx16 -msse4.1 -msse4.2 -mpopcnt

It gets part way there. What is not clear is how to say, 'not this' and 'not that', which for old CPUs would be, most likely, -mno-avx.

For an old cpu, which -march matters and Nephanth very usefully addresses this:

gcc -march=native -Q --help=target|grep march

produces

-march=                             westmere

which means my response to the ./compile question should be or might be, and note the quotes 'westmere' which is also in the gcc docs so the ' ' must be there for a reason

-march='westmere' -mssse3 -mcx16 -msse4.1 -msse4.2 -mpopcnt -mno-avx

but this is probably much better (see discussion below):

-march=native -mssse3 -mcx16 -msse4.1 -msse4.2 -mpopcnt -mno-avx

The -mno-avx is an option for gcc, and results, after many hours, in

Python 3.5.2 (default, Nov 23 2017, 16:37:01) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more 
information.
>>> import tensorflow as tf
>>> 
>>> tf.__version__
'2.0.0-alpha0'

which looks like success.

Restated: In either order, find out what instructions are (or not) supported by your cpu, and state those explicitly.

How to determine if my CPU supports AVX instructions, The current version of Tensorflow installed via pip uses the AVX a Tensorflow from the source that does not use the AVX instruction set. Fix: Your CPU Supports Instructions that this TensorFlow Binary was not Compiled to use AVX2. Advanced Vector Extensions ( AVX, also known as Sandy Bridge New Extensions) are extensions to the x86 instruction set architecture for microprocessors from Intel and AMD proposed by Intel in March 2008 and first supported by Intel with the Sandy Bridge processor shipping in Q1 2011 and later on by AMD with the Bulldozer processor shipping in Q3 2011.

Try Anaconda. It should have TensorFlow distribution for old CPUs. Compilation of TensorFlow is difficult.

How do I find out the version of TensorFlow on my computer?, My CPU doesn't support Tensorflow AVX instructions #34 CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 (depending on the version of the compiler) to enable the instructions. I don't know how to compile the tensorflow binary and which flags to use. The current version of Tensorflow installed via pip uses the AVX instruction set at compile time.This means that your CPU needs to support the AVX instruction set. This instruction set is supported from the second generation of Intel Core CPUs (codenamed SandyBridge).

You can find pre-built wheels(support for windows) here on Github : https://github.com/fo40225/tensorflow-windows-wheel or you can build your own wheels

I had the same issue too but i got it resolved.

Releases · tensorflow/tensorflow · GitHub, The TensorFlow library was compiled to use AVX instructions, but , The current version of Tensorflow installed via pip uses the AVX a Tensorflow from the source that does not use the AVX instruction set. Try Anaconda. "The TensorFlow library wasn't compiled to use AVX(etc) instructions, but these are available on your machine and could speed up CPU computations." If they are available on our machine, is it possible to download a pip archive with these features enabled? If not, it is a strong Feature request.

The TensorFlow library was compiled to use AVX instructions, but , supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA Advanced Vector AVX provides new features, new instructions, and a new coding scheme. We will start with uninstalling the default version of Tensorflow: Install Bazel, the build tool used to compile TensorFlow. conda install tensorflow. conda install tensorflow -c intel. conda install tensorflow-mkl. All these seem to fail to build the AVX AVX2 lib, as i keep getting the. Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX AVX2 141] AVX AVX2Your CPU

My CPU doesn't support Tensorflow AVX instructions · Issue #34 , that this TensorFlow binary was not compiled to use: AVX2 Starting with TensorFlow 1.6, binaries use AVX instructions which may not run on This would seem to indicate that if you had the opposite issue (your CPU did not support AVX), you a precompiled version with support for these instructions. In a freshly created anaconda installation, in an environment created with. conda create -n tensorflow_env tensorflow keras. I still get the warning "cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA"

Is there a version of TensorFlow not compiled for AVX instructions?, Compiling TensorFlow to use all available CPU instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA Currently there is no pre-compiled libtensorflow for version 2 and up (See  We’re also going to be doing this for TensorFlow version 2.0.1. Currently there is no pre-compiled libtensorflow for version 2 and up (See this issue for more). These instructions work for other versions, but some adjustments to the bazel version amongst others will be needed.

Comments
  • If you don't mind using an older version, TF wasn't compiled with AVX instructions up until version 1.5, so if you install that one you'll be aleto try out some stuff (and miss out on a lot more)
  • Otherwise, you'll either need to build it from source or try search for an unoffical wheel from someone, since TF now only supports CPUs with AVX
  • @GPhilo Would I be able to get a previous version via pip, or would I need to use something else?
  • pip install tensorflow=1.5
  • @GPhilo You're missing an equals: pip install tensorflow==1.5
  • If -march=native worked correctly for TensorFlow's bazel build script, that's all you'd need. It implies the other -m options on targets that support them. The fact that it doesn't work on its own means the build script must be eating it (and/or -mtune=native, too), and not passing it through to GCC like args that don't contain an =.
  • @user:224132 And indeed, the mystery continues, and I find myself entertaining another build, wherein it appears that something on the order of negatively stating what can't or shouldn't be done needs to be stated also, on the order of -mnoavx2, as my current build failed and I feel I should remove my answer. The construction of the configure file is remarkably unhelpful in this instance, at lease coming from more of a Make mind set,
  • I downloaded bazel a while ago to have a look at debugging TensorFlow's build script, but it was just layer upon layer of scripts. Since I don't use TensorFlow myself, I got bored and stopped.
  • On reflection, gcc won't do the mining to determine what native is as that implies tests, so native is probably a placeholder awaiting specificity arrived at by other means.
  • No, -march=native does work reliably, and does enable all the -m options supported by the CPU you're compiling on. If you run gcc -O3 -fverbose-asm -march=native -xc /dev/null -S -o- | less (compile an empty file as C, piping the asm output to stdout) you'll see asm comments showing which options were enabled/disabled. e.g. on my Skylake CPU, it shows -mavx2 -mfma -mbmi2 plus many many other things, along with detecting tuning settings like --param l1-cache-size=32 --param l1-cache-line-size=64. Presumably it uses the cpuid instruction to check CPU feature bits and cache.
  • Ideally, we should have an answer here in case the link provided goes 404