Kenhuang Academy
  • English

      • TensorFlow Environment Installation and Configuration

      System Requirements

      Operating System Support

      • Windows: Windows 7/10/11 (64-bit)
      • macOS: macOS 10.12.6 (Sierra) or higher
      • Linux: Ubuntu 16.04+, CentOS 7+, RHEL 7+

      Python Version

      • Python 3.7-3.11 (Recommended 3.8 or 3.9)
      • pip 19.0 or higher

      Hardware Requirements

      • CPU: Modern processor with AVX instruction set support
      • Memory: At least 4GB RAM (8GB+ recommended)
      • GPU: NVIDIA GPU (optional, for CUDA acceleration)
      • Storage: At least 2GB available space

      Installation Method Selection

      The simplest and most direct installation method, suitable for most users.

      2. conda Installation

      Suitable for users using Anaconda/Miniconda.

      3. Docker Installation

      Suitable for scenarios requiring isolated environments or deployment.

      4. Source Compilation

      Suitable for advanced users needing custom configuration.

      Detailed Installation Steps

      Method 1: Using pip

      1. Check Python Environment

      python --version
pip --version
      # Create virtual environment
python -m venv tensorflow_env

# Activate virtual environment
# Windows
tensorflow_env\Scripts\activate
# macOS/Linux
source tensorflow_env/bin/activate

      3. Upgrade pip

      pip install --upgrade pip

      4. Install TensorFlow

      CPU Version:

      pip install tensorflow

      GPU Version (requires CUDA support):

      pip install tensorflow[and-cuda]
# or
pip install tensorflow-gpu

      5. Verify Installation

      import tensorflow as tf
print(f"TensorFlow version: {tf.__version__}")
print(f"GPU available: {tf.config.list_physical_devices('GPU')}")

      Method 2: Using conda

      1. Install Anaconda or Miniconda

      Download and install from the official website: https://www.anaconda.com/

      2. Create conda Environment

      conda create -n tensorflow_env python=3.9
conda activate tensorflow_env

      3. Install TensorFlow

      # CPU version
conda install -c conda-forge tensorflow

# GPU version
conda install -c conda-forge tensorflow-gpu

      Method 3: Using Docker

      1. Install Docker

      Download and install Docker from the official website: https://www.docker.com/

      2. Pull TensorFlow Image

      # CPU version
docker pull tensorflow/tensorflow:latest

# GPU version
docker pull tensorflow/tensorflow:latest-gpu

# Jupyter version
docker pull tensorflow/tensorflow:latest-jupyter

      3. Run Container

      # Run CPU version
docker run -it --rm tensorflow/tensorflow:latest python

# Run GPU version (requires nvidia-docker)
docker run --gpus all -it --rm tensorflow/tensorflow:latest-gpu python

# Run Jupyter version
docker run -it --rm -p 8888:8888 tensorflow/tensorflow:latest-jupyter

      GPU Support Configuration

      1. NVIDIA GPU Requirements

      • CUDA Compute Capability 3.5 or higher
      • NVIDIA driver 450.80.02 or higher

      2. Install CUDA and cuDNN

      Windows Installation

      1. Download and install CUDA Toolkit: https://developer.nvidia.com/cuda-toolkit
      2. Download and install cuDNN: https://developer.nvidia.com/cudnn
      3. Copy cuDNN files to CUDA installation directory

      Linux Installation

      # Ubuntu CUDA installation
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/cuda-ubuntu2004.pin
sudo mv cuda-ubuntu2004.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda-repo-ubuntu2004-11-8-local_11.8.0-520.61.05-1_amd64.deb
sudo dpkg -i cuda-repo-ubuntu2004-11-8-local_11.8.0-520.61.05-1_amd64.deb
sudo cp /var/cuda-repo-ubuntu2004-11-8-local/cuda-*-keyring.gpg /usr/share/keyrings/
sudo apt-get update
sudo apt-get -y install cuda

      macOS Notes

      macOS does not support NVIDIA CUDA, but supports Metal Performance Shaders (MPS):

      # Check MPS support
import tensorflow as tf
print("MPS available:", tf.config.experimental.list_physical_devices('GPU'))

      3. Verify GPU Installation

      import tensorflow as tf

# Check GPU devices
print("GPU devices:", tf.config.list_physical_devices('GPU'))

# Check CUDA version
print("CUDA version:", tf.test.is_built_with_cuda())

# Test GPU computation
if tf.config.list_physical_devices('GPU'):
    with tf.device('/GPU:0'):
        a = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
        b = tf.constant([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
        c = tf.matmul(a, b)
        print("GPU computation result:", c)

      Verify Installation

      Create Test Script test_tensorflow.py:

      import tensorflow as tf
import numpy as np

def test_tensorflow_installation():
    print("=== TensorFlow Installation Verification ===")
    
    # Basic information
    print(f"TensorFlow version: {tf.__version__}")
    print(f"Keras version: {tf.keras.__version__}")
    print(f"Python version: {tf.version.VERSION}")
    
    # Hardware support
    print(f"CUDA support: {tf.test.is_built_with_cuda()}")
    print(f"GPU devices: {tf.config.list_physical_devices('GPU')}")
    
    # Basic tensor operation test
    print("\n=== Basic Function Tests ===")
    
    # CPU tensor operations
    a = tf.constant([1, 2, 3, 4])
    b = tf.constant([5, 6, 7, 8])
    c = tf.add(a, b)
    print(f"CPU tensor addition: {a} + {b} = {c}")
    
    # Matrix operations
    matrix_a = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)
    matrix_b = tf.constant([[5, 6], [7, 8]], dtype=tf.float32)
    matrix_c = tf.matmul(matrix_a, matrix_b)
    print(f"Matrix multiplication result:\n{matrix_c}")
    
    # GPU test (if available)
    if tf.config.list_physical_devices('GPU'):
        with tf.device('/GPU:0'):
            gpu_a = tf.constant([[1.0, 2.0], [3.0, 4.0]])
            gpu_b = tf.constant([[5.0, 6.0], [7.0, 8.0]])
            gpu_c = tf.matmul(gpu_a, gpu_b)
            print(f"GPU matrix multiplication result:\n{gpu_c}")
    
    # Automatic differentiation test
    x = tf.Variable(3.0)
    with tf.GradientTape() as tape:
        y = x ** 2
    dy_dx = tape.gradient(y, x)
    print(f"Automatic differentiation: d(x²)/dx at x=3 = {dy_dx}")
    
    # Keras model test
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(10, activation='relu', input_shape=(5,)),
        tf.keras.layers.Dense(1)
    ])
    
    # Test data
    test_input = tf.random.normal((3, 5))
    test_output = model(test_input)
    print(f"Keras model output shape: {test_output.shape}")
    
    print("\n✅ TensorFlow installation verification successful!")

if __name__ == "__main__":
    test_tensorflow_installation()

      Run the test:

      python test_tensorflow.py

      Common Issues and Solutions

      1. Import Error

      # Error: ModuleNotFoundError: No module named 'tensorflow'
# Solution: Ensure you're in the correct virtual environment, reinstall TensorFlow
pip install --upgrade tensorflow

      2. GPU Not Available

      # Check GPU status
import tensorflow as tf
print("Physical GPU:", tf.config.list_physical_devices('GPU'))
print("Logical GPU:", tf.config.list_logical_devices('GPU'))

# If GPU is not available, check CUDA and driver installation

      3. Version Compatibility Issues

      # View compatible CUDA version
python -c "import tensorflow as tf; print(tf.sysconfig.get_build_info())"

# Install specific version
pip install tensorflow==2.12.0

      4. Out of Memory

      # Configure GPU memory growth
import tensorflow as tf

gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
    try:
        for gpu in gpus:
            tf.config.experimental.set_memory_growth(gpu, True)
    except RuntimeError as e:
        print(e)

      5. Windows Long Path Issues

      # Enable long path support
git config --system core.longpaths true

      1. IDE Selection

      • PyCharm: Powerful Python IDE
      • VS Code: Lightweight, rich plugin ecosystem
      • Jupyter Notebook: Suitable for experimentation and learning
      • Google Colab: Free cloud environment

      2. Jupyter Notebook Configuration

      # Install Jupyter
pip install jupyter

# Install TensorFlow extensions
pip install tensorboard jupyter-tensorboard

# Start Jupyter
jupyter notebook

      3. VS Code Configuration

      Recommended extensions:

      • Python
      • Jupyter
      • TensorFlow Snippets
      • Python Docstring Generator

      4. Useful Python Packages

      pip install numpy pandas matplotlib seaborn scikit-learn pillow opencv-python

      Performance Optimization Recommendations

      1. Use Appropriate Data Types

      # Using float32 instead of float64 saves memory and improves speed
x = tf.constant([1.0, 2.0, 3.0], dtype=tf.float32)

      2. Enable Mixed Precision Training

      # Enable mixed precision
policy = tf.keras.mixed_precision.Policy('mixed_float16')
tf.keras.mixed_precision.set_global_policy(policy)

      3. Configure GPU Memory

      # Configure GPU memory usage
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
    try:
        # Set memory growth
        for gpu in gpus:
            tf.config.experimental.set_memory_growth(gpu, True)
        
        # Or limit memory usage
        tf.config.experimental.set_memory_limit(gpus[0], 1024)
    except RuntimeError as e:
        print(e)

      4. Use tf.function Decorator

      @tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        predictions = model(x, training=True)
        loss = loss_fn(y, predictions)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    return loss

      Update TensorFlow

      pip Update

      pip install --upgrade tensorflow

      conda Update

      conda update tensorflow

      View Release Notes

      import tensorflow as tf
print(tf.__version__)
# Visit https://github.com/tensorflow/tensorflow/releases for update details

      Docker Environment Detailed Configuration

      1. Create Custom Dockerfile

      FROM tensorflow/tensorflow:latest-gpu

# Set working directory
WORKDIR /app

# Install additional Python packages
RUN pip install --no-cache-dir \
    jupyter \
    matplotlib \
    seaborn \
    pandas \
    scikit-learn

# Copy project files
COPY . /app

# Expose port
EXPOSE 8888

# Startup command
CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]

      2. Build and Run

      # Build image
docker build -t my-tensorflow .

# Run container
docker run --gpus all -p 8888:8888 -v $(pwd):/app my-tensorflow

      Summary

      Proper installation and configuration of TensorFlow environment is the first step to a successful deep learning project. Recommendations:

      1. Prioritize Virtual Environments: Isolate project dependencies, avoid version conflicts
      2. Choose Version Based on Needs: CPU version for learning, GPU version for training
      3. Regular Updates: Keep the latest stable version, get performance improvements
      4. Configure Development Environment: Choose appropriate IDE and tools
      5. Performance Optimization: Reasonably configure GPU memory and data types

      After installation, you can start exploring TensorFlow's powerful features!