Title: How to install TensorFlow 2.0 on macOS - PyImageSearch

URL Source: https://pyimagesearch.com/2019/12/09/how-to-install-tensorflow-2-0-on-macos/

Published Time: 2019-12-09T15:00:06+00:00

Markdown Content:
[![Image 1](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20600'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2019/12/tensorflow2_install_macos_header.png)

In this tutorial, you will learn to install TensorFlow 2.0 on your macOS system running either Catalina or Mojave

There are a number of important updates in TensorFlow 2.0, including eager execution, automatic differentiation, and better multi-GPU/distributed training support, **but the _most important update_ is that Keras is now the _official_ high-level deep learning API for TensorFlow.**

Furthermore, if you own a copy of my book, [_Deep Learning for Computer Vision with Python_](https://pyimagesearch.com/deep-learning-computer-vision-python-book/), you should use this guide to properly install TensorFlow 2.0 on your macOS system.

Inside this tutorial, you’ll learn how to install TensorFlow 2.0 on macOS (using either Catalina or Mojave).

Alternatively, [click here for my **Ubuntu + TensorFlow 2.0** installation instructions](https://pyimagesearch.com/2019/12/09/how-to-install-tensorflow-2-0-on-ubuntu/).

**To learn how to install TensorFlow 2.0 on macOS, _just keep reading._**

In the first part of this tutorial, we’ll briefly discuss the pre-configured deep learning development environments that are a part of my book, _[Deep Learning for Computer Vision with Python](https://pyimagesearch.com/deep-learning-computer-vision-python-book/)._

We’ll then configure and install TensorFlow 2.0 on our macOS system.

Let’s begin.

### Pre-configured deep learning environments

![Image 2](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20597%20476'%3E%3C/svg%3E)

**Figure 1:** My deep learning Virtual Machine with TensorFlow, Keras, OpenCV, and all other Deep Learning and Computer Vision libraries you need, pre-configured and pre-installed.

When it comes to working with deep learning and Python I _highly recommend_ that you use a Unix-based environment.

Deep learning tools can be more easily configured and installed on Unix systems, allowing you to develop and run neural networks quickly.

Of course, configuring your own deep learning + Python + Linux development environment can be quite the tedious task, _especially_ if you are new to Unix, a beginner at working the command line/terminal, or a novice when compiling and installing packages by hand.

In order to help you jump start your deep learning + Python education, I have created two pre-configured environments:

1.  [**Pre-configured VirtualBox Ubuntu Virtual Machine (VM)**](https://pyimagesearch.com/2017/09/22/deep-learning-python-ubuntu-virtual-machine/) with all necessary deep learning libraries you need to be successful (including _Keras_, _TensorFlow_, _scikit-learn_, _scikit-image_, _OpenCV_, and others) **_pre-configured_** and **_pre-installed_**.
2.  [**Pre-configured Deep Learning Amazon Machine Image (AMI)**](https://pyimagesearch.com/2017/09/20/pre-configured-amazon-aws-deep-learning-ami-with-python/) which runs on Amazon Web Service’s (AWS) Elastic Compute (EC2) infrastructure. This environment is free for anyone on the internet to use regardless of whether you are a DL4CV customer of mine or not (cloud/GPU fees apply). Deep learning libraries are _**pre-installed**_ including both those listed in #1 in addition to _TFOD API_, _Mask R-CNN_, _RetinaNet_, and _mxnet_.

I **_strongly urge_** you to consider using my pre-configured environments if you are working through my books. Using a pre-configured environment is not cheating — **they simply allow you to focus on learning rather than the job of a system administrator.**

If you are more familiar with Microsoft Azure’s infrastructure, be sure to [check out their Ubuntu Data Science Virtual Machine (DSVM), including my review of the environment](https://pyimagesearch.com/2018/03/21/my-review-of-microsofts-deep-learning-virtual-machine/). The Azure team maintains a great environment for you and I cannot speak highly enough about the support they provided while I ensured that all of my deep learning chapters ran successfully on their system.

That said, pre-configured environments are not for everyone.

In the remainder of this tutorial, we will serve as the “deep learning systems administrators” installing TensorFlow 2.0 on our bare metal macOS machine.

### Configuring your macOS TensorFlow 2.0 deep learning system

The following instructions for installing TensorFlow 2.0 on your machine assume either:

*   You have administrative access to your system
*   You can open a terminal and or you have an active SSH connection to the target machine
*   You know how to operate the command line.

Let’s get started!

#### Step #1: Choose your macOS deep learning platform — either Catalina or Mojave

[![Image 3](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20379'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2019/12/tensorflow2_install_macos_mojave_catlina.png)

**Figure 3:** This tutorial supports installing TensorFlow 2.0 on macOS Mojave or macOS Catalina.

These TensorFlow 2.0 install instructions in this guide are compatible with the following operating systems:

1.  **macOS:** 10.15 “Catalina”
2.  **macOS:** 10.14 “Mojave”

Alternatively, [you may follow my Ubuntu + TensorFlow 2.0 installation instructions](https://pyimagesearch.com/2019/12/09/how-to-install-tensorflow-2-0-on-ubuntu/).

_**Note:** You may be wondering “What about Windows?” Keep in mind I do not support Windows on the PyImageSearch blog. [You can read more about my “no Windows policy” in my FAQ](https://pyimagesearch.com/faqs/single-faq/can-you-help-me-do-___-on-windows)._

#### Step #2 (Catalina only): Choose Bash or ZSH as your shell

This step is for **macOS Catalina _only_**. If you use Mojave, please ignore this step and skip to **Step #3**.

On macOS Catalina, you have the option of using a Bash shell or ZSH shell.

**Bash is probably what you’re used to.** Previous versions of macOS have used Bash and by default, Ubuntu uses Bash as well. **Apple has now made a decision that going forward, their operating systems will use ZSH.**

_**So what’s the big deal and should I switch?**_

Describing the differences between Bash and ZSH is outside the scope of this post — it’s entirely up to you to decide. I would recommend reading this [ZSH vs. Bash tutorial](https://stackabuse.com/zsh-vs-bash/) to get you started, but again, the choice is up to you.

On one hand, you may discover that the changes do not impact you much and that using ZSH will be very comparable to Bash. Power users, on the other hand, may notice additional features.

If you _upgraded_ from High Sierra or Mojave to Catalina, by default your system will likely use Bash unless you explicitly change it by going into your terminal profile settings.

If your computer _came with Catalina installed or you installed Catalina from scratch_, then your system will likely use ZSH by default.

Either way, if you decide to need make the switch on Catalina, you can [follow these instructions to set your profile to use ZSH](http://osxdaily.com/2018/12/29/use-zsh-default-terminal-mac-os-x/).

Changing your shell is relatively simple via your _“Terminal Preferences” > “Profiles” > “Shell”_ menu as shown in **Figure 4**:

[![Image 4](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20427'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2019/12/tensorflow2_install_macos_zsh.png)

**Figure 4:** Changing your macOS Catalina shell to ZSH (left), a step you may wish to do before installing TensorFlow 2.0 on macOS (**[click for high-res](https://pyimagesearch.com/wp-content/uploads/2019/12/tensorflow2_install_macos_zsh.png)**).

**The shell you use determines which terminal profile you edit later in this install guide:**

*   **ZSH:** `~/.zshrc`
*   **Bash:** `~/.bash_profile`

ZSH will accommodate `~/.bash_profile` if you source it from within `~/.zshrc` . Just keep in mind that not all settings will work. For example, in my `~/.bash_profile` , I had a custom bash prompt which showed only the current lowest level working directory (shorter) and also which branch of a Git repository I’m working on (useful for software development). The problem is that ZSH didn’t like my custom Bash prompt, so I had to remove it. I’ll have to set up a custom ZSH prompt in the future.

Realistically, it is probably better if you copy the settings from your Bash Profile that you need into your ZSH profile and ensure that they work. Alternatively, you can source your Bash Profile within your ZSH Profile (i.e. insert `source ~/.bash_profile` as a line into your `~/.zshrc` file — then open a fresh shell or reload it with the `source ~/.zshrc` command).

If you were previously working in Bash (i.e. you upgraded to Catalina), you may encounter the following message in your terminal:

The default interactive shell is now zsh.
To update your account to use zsh, please run chsh -s /bin/zsh
For more details, please visit https://support.apple.com/kb/HT208050.

This means that to switch shells, you should enter the command at the prompt:

$ chsh -s /bin/zsh

**Note that the ZSH prompt is `%` . The remainder of this tutorial will show `$` at the beginning of the prompt, but you can think of it as `%` if you are using ZSH.**

#### Step #3: Install macOS deep learning dependencies

[![Image 5](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20699'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2019/12/tensorflow2_instal_macos_xcode.png)

**Figure 5:** Prior to installing TensorFlow 2.0 on macOS Mojave or macOS Catalina, you must install Xcode from the App Store.

In either version of macOS, go ahead and open your macOS App Store and find and **download/install Xcode** (**Figure 5**).

From there, accept the Xcode license in the terminal:

$ sudo xcodebuild -license

Press the `space` key as you read the agreement. Then type `agree` at the prompt.

And then install Xcode select:

$ sudo xcode-select --install

**_Note:_** _If you encounter this error message `xcode-select: error: tool 'xcodebuild' requires Xcode, but active developer directory '/Library/Developer/CommandLineTools' is a command line tools instance`_ _you may need to follow [these SOF instructions](https://stackoverflow.com/questions/17980759/xcode-select-active-developer-directory-error)._

[![Image 6](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20189'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2019/12/tensorflow2_install_macos_xcode_select.png)

**Figure 6:** To install TensorFlow 2.0 on macOS Mojave/Catalina, be sure to install the Xcode-select tools.

The unofficial, community-driven package manager for macOS is called **Homebrew** (brew for short). Many packages that you could install with Aptitude (apt) on Ubuntu are available via HomeBrew on macOS.

We’ll use Homebrew to install a handful of dependencies. It does not come pre-installed on macOS, so let’s install it now (only do this if you don’t already have Homebrew):

$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

From there, update Homebrew:

$ brew update

Now go ahead and edit your ZSH Profile or Bash Profile. **Be sure that you update the correct file depending on whether you use ZSH or Bash on macOS:**

1.  `~/.zshrc` (ZSH)
2.  `~/.bash_profile` (Bash)

$ nano ~/.zshrc # ZSH
$ nano ~/.bash\_profile # Bash

Again, you should only be editing _one_ of the above files based on which shell your macOS system is using.

From there, insert the following lines at the end of your profile:

\# Homebrew
export PATH=/usr/local/bin:$PATH

Save the file (`ctrl + x` , `y` , `enter` ) and exit to your terminal.

Now go ahead and source the profile (i.e. reload it):

$ source ~/.zshrc # ZSH
$ source ~/.bash\_profile # Bash

Once again, only _one_ of the above commands should be executed depending on which macOS shell you are using.

We’re now ready to **install Python 3:**

$ brew install python3

Let’s check that our Python 3 is properly linked at this point:

$ which python3
/usr/local/bin/python3

_**Warning:** In our experience, Python 3.8 is not compatible with TensorFlow 2.0. We suggest installing TensorFlow 2.2+ in **Step #5** if your system has Python 3.8 installed. Otherwise, sticking with Python 3.6 or 3.7 is a safe bet. Be sure to check your Python version by executing `python3 --version`._

You should verify that the output path begins with `/usr/local`. If it does not, then double-check that Homebrew’s Python is installed. We do not want to use the system Python as our virtual environments will be based on Homebrew’s Python.

At this point, Homebrew and Python are ready for us to **install dependencies:**

$ brew install cmake pkg-config wget
$ brew install jpeg libpng libtiff openexr
$ brew install eigen tbb hdf5

Our dependencies include compiler tools, image I/O, optimization tools, and HDF5 for working with large datasets/serialized files.

Great job installing dependencies on macOS — you can now proceed to **Step #4**.

_**Warning:**_ _In this section we worked with Homebrew. Never execute a `brew` command while you are in a virtual environment described by **Step #4** because it can be difficult to recover your system’s package and dependency tree from there. If you see that your bash/ZSH prompt begins with `({env_name})` then you are in a Python virtual environment_ _and you should execute deactivate before running a `brew` command._

#### Step #4: Install pip and virtual environments

In this step, we will set up pip and Python virtual environments.

We will use the de-facto Python package manager, pip.

_**Note:** While you are welcome to opt for Anaconda (or alternatives), I’ve still found pip to be more ubiquitous in the community. Feel free to use Anaconda if you so wish, just understand that I cannot provide support for it._

Let’s download and install pip:

$ wget https://bootstrap.pypa.io/get-pip.py
$ sudo python3 get-pip.py

To complement pip, I recommend using both [virtualenv](https://virtualenv.pypa.io/en/latest/) and [virtualenvwrapper](https://virtualenvwrapper.readthedocs.io/en/latest/) to manage virtual environments.

Virtual environments are a best practice when it comes to Python development. They allow you to test different versions of Python libraries in sequestered development and production environments. I use them daily and you should too for all Python development.

In other words, do not install TensorFlow 2.0 and associated Python packages directly to your system environment. It will only cause problems later.

Let’s install my preferred virtual environment tools now:

$ pip3 install virtualenv virtualenvwrapper

_**Note:** Your system may require that you use the `sudo` command to install the above virtual environment tools. This will only be required once — from here forward, do not use `sudo` ._

From here, we need to update our bash profile:

$ nano ~/.zshrc # ZSH
$ nano ~/.bash\_profile # Bash

Only edit _one_ of the files above based on which shell your macOS system uses.

Next, enter the following lines at the bottom of the file:

\# virtualenv and virtualenvwrapper
export WORKON\_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER\_PYTHON=/usr/local/bin/python3
source /usr/local/bin/virtualenvwrapper.sh

Save the file (`ctrl + x` , `y` , `enter` ) and exit to your terminal.

[![Image 7](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20338'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2019/12/tensorflow2_install_macos_profile.png)

**Figure 7:** How to install TensorFlow 2.0 on macOS. This figure shows the Bash or ZSH profile in macOS configured with Homebrew and virtualenvwrapper.

Don’t forget to source the changes in your profile:

$ source ~/.zshrc # ZSH
$ source ~/.bash\_profile # Bash

You only need to execute _one_ of the commands above — just verify which shell you are using first (either ZSH or Bash).

Output will be displayed in your terminal indicating that `virtualenvwrapper` is installed.

_**Note:** If you encounter errors here, you need to address them before moving on. Usually, errors at this point are due to typos in your Bash/ZSH profile._

Now we’re ready to create your **Python 3** deep learning **virtual** **environment** named `dl4cv`:

$ mkvirtualenv dl4cv -p python3

You can create similar virtual environments with different names (and packages therein) as needed. On my personal system, I have many virtual environments. For developing and testing software for my book, _[Deep Learning for Computer Vision with Python](https://pyimagesearch.com/deep-learning-computer-vision-python-book/)_, I like to name (or precede the name of) the environment with `dl4cv` . That said, feel free to use the nomenclature that makes the most sense to you.

Great job setting up virtual environments on your system!

#### Step #5: Install TensorFlow 2.0 into your `dl4cv` virtual environment on macOS

In this step, we’ll install TensorFlow 2.0.

A prerequisite of TensorFlow is NumPy for numerical processing. Go ahead and install NumPy and TensorFlow 2.0 using pip:

$ pip install numpy
$ pip install tensorflow==2.0.0

Great job installing TensorFlow 2.0!

#### Step #6: Install associated packages into your `dl4cv` **virtual environment**

[![Image 8](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20442'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2019/12/tensorflow2_install_ubuntu_libraries.png)

**Figure 8:** A fully-fledged TensorFlow 2.0 deep learning environment requires a handful of other Python libraries as well.

In this step, we will install additional packages needed for common deep learning development.

We begin with standard image processing libraries including OpenCV:

$ pip install opencv-contrib-python
$ pip install scikit-image
$ pip install pillow
$ pip install imutils

These image processing libraries will allow us to perform image I/O, various preprocessing techniques, as well as graphical display.

From there, let’s install machine learning libraries and support libraries including scikit-learn and matplotlib:

$ pip install scikit-learn
$ pip install matplotlib
$ pip install progressbar2
$ pip install beautifulsoup4
$ pip install pandas

Great job installing associated image processing and machine learning libraries.

#### Step #7: Test your install

In this step, as a quick sanity test, we’ll test our install.

Fire up a Python shell in your `dl4cv` environment (or whatever you named your Python virtual environment) and ensure that you can import the following packages:

$ workon dl4cv
$ python
>>> import tensorflow as tf
>>> tf.\_\_version\_\_
2.0.0
>>> import tensorflow.keras
>>> import cv2
>>> cv2.\_\_version\_\_
4.1.2

_**Note:** If you are on Python 3.7.3 (**Catalina**) and Clang 11.0 you could encounter [this error.](https://github.com/tensorflow/tensorflow/issues/33183) This is a known issue with a solution is available [here](https://github.com/tensorflow/tensorflow/issues/33183#issuecomment-543931248)._

[![Image 9](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20418'%3E%3C/svg%3E)](https://pyimagesearch.com/wp-content/uploads/2019/12/tensorflow2_install_macos_test.png)

**Figure 8:** Testing TensorFlow 2.0 installation on macOS inside a Python interpreter.

### Accessing your TensorFlow 2.0 virtual environment

At this point, your TensorFlow 2.0 `dl4cv` environment is ready to go. Whenever you would like to execute TensorFlow 2.0 code (such as from my [deep learning book](https://pyimagesearch.com/deep-learning-computer-vision-python-book/)), be sure to use the `workon` command to drop into the Python virtual environment where TensorFlow 2.0 is installed:

$ workon dl4cv

Your ZSH or Bash prompt will be preceded with `(dl4cv)` indicating that you are “inside” the TensorFlow 2.0 virtual environment.

If you need to get back to your system-level environment, you can deactivate the current virtual environment:

$ deactivate

### Frequently Asked Questions (FAQ)

**Q: These instructions seem really complicated. Do you have a pre-configured environment?**

A: Yes, the instructions can be daunting. I recommend brushing up on your Unix command line skills prior to following these instructions.

That said, I do offer two _pre-configured environments_ for my book:

1.  **[Pre-configured Deep Learning Virtual Machine](https://pyimagesearch.com/2017/09/22/deep-learning-python-ubuntu-virtual-machine/):** My VirtualBox VM is included with your purchase of [my deep learning book](https://pyimagesearch.com/deep-learning-computer-vision-python-book/). Just download the VirtualBox and import the VM into VirtualBox. From there, boot it up and you’ll be running example code in a matter of minutes.
2.  **[Amazon Machine Image (EC2 AMI)](https://pyimagesearch.com/2017/09/20/pre-configured-amazon-aws-deep-learning-ami-with-python/):** Free for everyone on the internet. You can use this environment with no strings attached even if you don’t own my deep learning book (AWS charges apply, of course). Again, compute resources on AWS are not free — you will need to pay for cloud/GPU fees but not the AMI itself. Arguably, working on a deep learning rig in the cloud is cheaper and less time-consuming than keeping a deep learning box on-site. Free hardware upgrades, no system admin headaches, no calls to hardware vendors about warranty policies, no power bills, pay only for what you use. This is the best option if you have a few one-off projects and don’t want to invest in hardware.

**Q: Why didn’t we install Keras?**

A: Keras is officially part of TensorFlow as of TensorFlow v1.10.0. By installing TensorFlow 2.0 the Keras API is inherently installed.

Keras has been deeply embedded into TensorFlow and `tf.keras` is the primary high-level API in TensorFlow 2.0. The legacy functions that come with TensorFlow play nicely with `tf.keras` now.

In order to understand the difference between Keras and `tf.keras` in a more detailed manner, check out my recent [blog post](https://pyimagesearch.com/2019/10/21/keras-vs-tf-keras-whats-the-difference-in-tensorflow-2-0/).

You may now import Keras using the following statement in your Python programs:

$ workon dl4cv
$ python
>>> import tensorflow.keras
>>>

**Q: Do these instructions support macOS Mojave and macOS Catalina?**

A: Yes, these instructions have been fully tested on Mojave and Catalina. That said, Homebrew changes often and can be the source of problems. If you are having an issue, please [contact me](https://pyimagesearch.com/contact) or drop a comment below. Please be respectful of this webpage and my email inbox by not dumping large amounts of terminal output. Keep in mind this [PyImageSearch policy on debugging development environments](https://pyimagesearch.com/faqs/single-faq/can-you-help-me-setup-or-debug-my-development-environment/) as well.

**Q: I’m really stuck. Something is not working. Can you help me?**

A: I really love helping readers and I would love to help you configure your deep learning development environment.

That said, I receive 100+ emails and blog post comments per day — I simply don’t have the time to get to them all

Customers of mine receive support priority over non-customers due to the number of requests myself and my team receive. Please consider becoming a customer by browsing **[my library of books and courses](https://pyimagesearch.com/books-and-courses/)**.

My personal recommend is that you to grab a copy of [_Deep Learning for Computer Vision with Python_](https://pyimagesearch.com/deep-learning-computer-vision-python-book/) — that book includes access to my pre-configured deep learning development environments that have TensorFlow, Keras, OpenCV, etc. _pre-installed._ You’ll be up and running in a matter of minutes.

### What's next? We recommend [PyImageSearch University](https://pyimagesearch.com/pyimagesearch-university/?utm_source=blogPost&utm_medium=bottomBanner&utm_campaign=What%27s%20next%3F%20I%20recommend).

**Course information:**  
84 total classes • 114+ hours of on-demand code walkthrough videos • Last updated: February 2024  
★★★★★ 4.84 (128 Ratings) • 16,000+ Students Enrolled

**I strongly believe that if you had the right teacher you could _master_ computer vision and deep learning.**

Do you think learning computer vision and deep learning has to be time-consuming, overwhelming, and complicated? Or has to involve complex mathematics and equations? Or requires a degree in computer science?

That’s _not_ the case.

All you need to master computer vision and deep learning is for someone to explain things to you in _simple, intuitive_ terms. _And that’s exactly what I do_. My mission is to change education and how complex Artificial Intelligence topics are taught.

If you're serious about learning computer vision, your next stop should be PyImageSearch University, the most comprehensive computer vision, deep learning, and OpenCV course online today. Here you’ll learn how to _successfully_ and _confidently_ apply computer vision to your work, research, and projects. Join me in computer vision mastery.

**Inside PyImageSearch University you'll find:**

*   ✓ **84 courses** on essential computer vision, deep learning, and OpenCV topics
*   ✓ **84 Certificates** of Completion
*   ✓ **114+ hours** of on-demand video
*   ✓ **Brand new courses released _regularly_**, ensuring you can keep up with state-of-the-art techniques
*   ✓ **Pre-configured Jupyter Notebooks in Google Colab**
*   ✓ Run all code examples in your web browser — works on Windows, macOS, and Linux (no dev environment configuration required!)
*   ✓ Access to **centralized code repos for _all_ 536+ tutorials** on PyImageSearch
*   ✓ **Easy one-click downloads** for code, datasets, pre-trained models, etc.
*   ✓ **Access** on mobile, laptop, desktop, etc.

[Click here to join PyImageSearch University](https://pyimagesearch.com/pyimagesearch-university/?utm_source=blogPost&utm_medium=bottomBanner&utm_campaign=What%27s%20next%3F%20I%20recommend)

Summary
-------

In this tutorial, you learned how to installed TensorFlow 2.0 on macOS (either on Catalina or Mojave).

Now that your deep learning rig is configured, I would suggest picking up a copy of _[Deep Learning for Computer Vision with Python](https://pyimagesearch.com/deep-learning-computer-vision-python-book/)._ You’ll be getting a great education and you’ll learn how to successfully apply Deep Learning to your own projects.

**To be notified when future tutorials are published here on PyImageSearch, _just enter your email address in the form below!_**

![Image 10](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20410%20567'%3E%3C/svg%3E)

#### Join the PyImageSearch Newsletter and Grab My FREE 17-page Resource Guide PDF

Enter your email address below to **join the PyImageSearch Newsletter** and **download my FREE 17-page Resource Guide PDF** on Computer Vision, OpenCV, and Deep Learning.