Python Environment Setup for Deep Learning

Setting up a dedicated Python workspace is fundamental for writing and running deep learning code effectively. This process is comparable to preparing a workshop before starting a new project. An organized environment ensures that your required software libraries are correctly installed and avoid conflicts with other development work.

For deep learning, and specifically for working with libraries like PyTorch and Keras, managing software dependencies is important. Different projects might require different versions of these libraries, and installing everything globally can lead to conflicts. To avoid this, we'll use a virtual environment. A virtual environment is an isolated Python setup, allowing you to have a specific set of libraries and versions for each project.

Why a Dedicated Environment?

Imagine you're working on two different Python projects. Project A requires version 1.0 of a library, while Project B needs version 2.0. If you install these libraries system-wide, one project will likely break. Virtual environments solve this by creating a self-contained directory for each project, with its own Python interpreter and installed packages.

For this course, we recommend using Anaconda. Anaconda is a popular distribution of Python and R for scientific computing and data science. It simplifies package management and deployment. It comes with conda, a powerful package and environment manager, and hundreds of pre-installed scientific packages.

If you don't have Anaconda installed, you can download it from the official Anaconda website. Choose the installer appropriate for your operating system (Windows, macOS, or Linux) and follow the installation instructions. We recommend selecting the Python 3.x version.

Creating Your Project Environment with Conda

Once Anaconda is installed, you can create a new virtual environment for this course. Open your terminal (Anaconda Prompt on Windows, or Terminal on macOS/Linux) and use the following command:

conda create --name autoencoder_env python=3.9

Let's break down this command:

• conda create: This is the conda command to create a new environment.
• --name autoencoder_env: This specifies the name of our environment. We're calling it autoencoder_env, but you can choose another name if you prefer.
• python=3.9: This tells conda to install Python version 3.9 in this environment. While newer versions might be available, 3.9 is a stable choice for deep learning libraries. You can check for more recent stable versions if you wish.

Conda will then show you what packages will be installed and ask for your confirmation. Type y and press Enter.

After the environment is created, you need to activate it. Activating an environment means that your terminal session will now use the Python interpreter and packages installed within that specific environment.

To activate your new environment, use:

conda activate autoencoder_env

Your terminal prompt should change to indicate that the autoencoder_env is active, usually by prefixing the prompt with (autoencoder_env).

When you're done working in this environment and want to return to your system's default Python, you can deactivate it:

conda deactivate

For now, keep the autoencoder_env active as we'll be installing the necessary libraries next.

Installing Essential Libraries

With your autoencoder_env active, we can now install the Python libraries we'll need to build and train our autoencoders. The primary libraries for this course are:

1. PyTorch: An open-source machine learning framework known for its flexibility and ease of use. Keras, our high-level API for building neural networks, can use PyTorch as its backend.
2. NumPy: A fundamental package for numerical computation in Python. It's essential for handling the data arrays that neural networks process.
3. Matplotlib: A plotting library for creating static, animated, and interactive visualizations in Python. We'll use it to display images and plot results.

You can install these libraries using conda install or pip install. It's generally recommended to use conda install when you're within a conda environment, as conda handles dependencies well. However, pip (Python's default package installer) can also be used if a package isn't available through conda channels or if you need a very specific version.

Let's install PyTorch and configure Keras 3 to use the PyTorch backend.

pip install torch torchvision
pip install "keras-core~=0.1.0"
pip install "keras~=3.0"

Next, install NumPy and Matplotlib:

conda install numpy matplotlib

Conda (or pip) will download and install the packages and their dependencies. Again, you might be asked to confirm the installation.

Working with Jupyter Notebooks or JupyterLab (Recommended)

For writing and running Python code interactively, especially in data science and machine learning, Jupyter Notebooks or JupyterLab are excellent tools. They allow you to create documents that contain live code, equations, visualizations, and narrative text.

Anaconda usually comes with Jupyter Notebook. If you prefer JupyterLab (a more advanced interface), or if it's not installed, you can add it to your environment:

conda install jupyterlab

Or for the classic Jupyter Notebook:

conda install notebook

To start JupyterLab, ensure your autoencoder_env is active, then type:

jupyter lab

Or for Jupyter Notebook:

jupyter notebook

This will typically open a new tab in your web browser, showing the Jupyter interface. From here, you can create new notebooks and start coding. When you create a new notebook, make sure it's using the kernel associated with your autoencoder_env so it has access to the libraries we just installed.

Verifying Your Setup

A quick way to check if PyTorch is installed correctly is to open a Python interpreter or a new Jupyter Notebook and run the following commands. We will also set the Keras backend.

import os
os.environ["KERAS_BACKEND"] = "torch"

import torch
print(torch.__version__)

import keras
print(keras.__version__)

import numpy as np
print(np.__version__)

import matplotlib
print(matplotlib.__version__)

If these commands run without errors and print the version numbers of the libraries, your environment is ready!

You've now successfully set up a dedicated Python environment for your deep learning projects. This isolated setup will help keep your projects organized and ensure that you have the correct versions of all necessary tools. In the next section, we'll take a closer look at PyTorch and Keras, the tools we'll use to construct our autoencoder.