Configuration de l'environnement TensorFlow

TensorFlow 2.x a des exigences spécifiques pour les versions de Python :

Version de TensorFlow Prise en charge des versions de Python
TensorFlow 2.15+ Python 3.9-3.12
TensorFlow 2.12-2.14 Python 3.8-3.11
TensorFlow 2.8-2.11 Python 3.7-3.10

Python 3.9-3.11 est recommandéCes versions offrent la meilleure compatibilité et stabilité.

Vérifier la version actuelle de Python

# 检查 Python 版本
python --version
# ou 
python3 --version

# 检查 pip 版本
pip --version
# ou 
pip3 --version

Options d'installation de Python

Option 1 : Python officiel (recommandé pour les débutants)

  • Visitezpython.orgTélécharger et installer
  • Cochez « Ajouter Python au PATH » pendant l'installation
  • Inclut le gestionnaire de paquets pip

Option 2 : Anaconda/Miniconda (Recommandé pour la science des données)

  • Anaconda : environnement complet pour la science des données
  • Miniconda : version légère
  • Gestion intégrée des environnements et des paquets

Option 3 : Gestionnaire de paquets système

# Ubuntu/Debian
sudo apt update
sudo apt install python3 python3-pip

# macOS (使用 Homebrew)
brew install python3

# Windows (使用 Chocolatey)
choco install python3

Configuration d'un environnement virtuel (fortement recommandé)

Pourquoi utiliser un environnement virtuel

Avantages：

  • Isolation des dépendances: évite les conflits de versions de paquets entre différents projets
  • Environnement propre: maintient l'environnement Python du système propre
  • Gestion facile: supprimer et recréer facilement les environnements
  • Reproductibilité: facilite la reproduction des environnements sur différentes machines

Création d'un environnement virtuel avec venv

# 创建虚拟环境
python -m venv tensorflow_env

# 激活虚拟环境
# Windows:
tensorflow_env\Scripts\activate
# macOS/Linux:
source tensorflow_env/bin/activate

# 确认激活（提示符会显示环境名）
which python  # 应该指向虚拟环境中的 python

# 升级 pip
python -m pip install --upgrade pip

Création d'un environnement virtuel avec Conda

# 创建新环境
conda create -n tensorflow_env python=3.10

# 激活环境
conda activate tensorflow_env

# 列出所有环境
conda env list

# 在环境中安装包
conda install pip

Gestion des environnements virtuels

# 查看已安装的包
pip list

# 生成依赖文件
pip freeze > requirements.txt

# 从文件安装依赖
pip install -r requirements.txt

# 退出虚拟环境
deactivate  # venv
conda deactivate  # conda

# 删除虚拟环境
rm -rf tensorflow_env  # venv
conda env remove -n tensorflow_env  # conda

Installation de TensorFlow

Installation de la version CPU (adaptée à l'apprentissage et aux tâches légères)

# 确保在虚拟环境中
pip install tensorflow

# 验证安装
python -c "import tensorflow as tf; print('TensorFlow version:', tf.__version__)"

Caractéristiques de la version CPU：

  • Avantages: Installation simple, aucune configuration supplémentaire requise
  • Inconvénients: Vitesse d'entraînement plus lente, adaptée aux données à petite échelle
  • Scénarios d'application: Apprentissage, prototypage, déploiement d'inférence

Installation de la version GPU (adaptée à l'entraînement à grande échelle)

L'accélération GPU peut considérablement améliorer la vitesse d'entraînement, en particulier pour les tâches d'apprentissage profond.

3.2.1 Prérequis GPU NVIDIA

Configuration matérielle requise：

  • GPU NVIDIA (Capacité de calcul 3.5 ou supérieure)
  • 8GB+ VRAM (Recommandé)

Afficher les informations sur le GPU：

# Windows
nvidia-smi

# Linux
lspci | grep -i nvidia

Installation de CUDA et cuDNN

Correspondance entre TensorFlow 2.15+ et la version de CUDA：

TensorFlow CUDA cuDNN
2.15+ 12.2 8.9
2.12-2.14 11.8 8.6

Étapes d'installation：

  1. Télécharger et installer CUDA Toolkit

    • VisitezNVIDIA CUDA Toolkit
    • Sélectionnez la version correspondante à télécharger et installer
    • Ajouter au PATH système

  2. Télécharger et installer cuDNN

    • VisitezNVIDIA cuDNN
    • Enregistrement d'un compte NVIDIA requis
    • Extraire vers le répertoire d'installation de CUDA

  3. Vérifier l'installation de CUDA

    nvcc --version
nvidia-smi

Installer la version GPU de TensorFlow

# TensorFlow 2.10+ 统一包名
pip install tensorflow

# 验证 GPU 可用性
python -c "
import tensorflow as tf
print('TensorFlow version:', tf.__version__)
print('GPU available:', tf.config.list_physical_devices('GPU'))
print('Built with CUDA:', tf.test.is_built_with_cuda())
"

Installation via Conda

# CPU 版本
conda install tensorflow

# 或从 conda-forge
conda install -c conda-forge tensorflow

# GPU 版本（自动安装 CUDA）
conda install tensorflow-gpu

Installation d'une version spécifique

# 安装特定版本
pip install tensorflow==2.14.0

# 安装预发布版本
pip install tf-nightly

# 升级到最新版本
pip install --upgrade tensorflow

Installation des outils de développement

upyter Notebook/Lab

Jupyter est l'environnement de développement standard pour la science des données et l'apprentissage automatique :

# 安装 Jupyter Notebook
pip install jupyter notebook

# 或安装 JupyterLab（推荐）
pip install jupyterlab

# 启动 Jupyter
jupyter notebook
# ou 
jupyter lab

Extensions Jupyter：

# 安装有用的扩展
pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user

# 变量检查器
pip install nbextensions

Sélection de l'IDE

Visual Studio Code (recommandé)：

  • Installer l'extension Python
  • Installer l'extension Jupyter
  • Complétion de code intelligente et débogage

PyCharm：

  • IDE Python professionnel
  • Fonctionnalités de débogage puissantes
  • Prise en charge intégrée de Git

Google Colab (option cloud)：

  • Utilisation gratuite du GPU
  • Bibliothèques courantes préinstallées
  • Aucune configuration locale requise

Paquets Python requis

# 数据处理
pip install numpy pandas matplotlib seaborn

# 科学计算
pip install scipy scikit-learn

# 图像处理
pip install pillow opencv-python

# 进度条和实用工具
pip install tqdm

# 创建完整的要求文件
cat > requirements.txt << EOF
tensorflow>=2.12.0
numpy>=1.21.0
pandas>=1.3.0
matplotlib>=3.5.0
seaborn>=0.11.0
scikit-learn>=1.0.0
jupyter>=1.0.0
tqdm>=4.60.0
pillow>=8.0.0
EOF

# 批量安装
pip install -r requirements.txt

Vérification de la configuration

Script complet de vérification de l'installation

Créezverify_installation.pyfichier :

Exemple

#!/usr/bin/env python3
"""
Script de vérification de l'installation de TensorFlow
"""

import sys
print("Version de Python :", sys.version)
print("-" * 50)

# Vérifier TensorFlow
try:
    import tensorflow as tf
    print(f"✓ Version de TensorFlow: {tf.__version__}")
    print(f"✓ Version de Keras: {tf.keras.__version__}")
   
    # Vérifier la prise en charge du GPU
    physical_devices = tf.config.list_physical_devices('GPU')
    if physical_devices:
        print(f"✓ Périphériques GPU trouvés: {len(physical_devices)}")
        for i, device in enumerate(physical_devices):
            print(f" - GPU {i}: {device}")
        print(f"✓ CUDA compilé: {tf.test.is_built_with_cuda()}")
    else:
        print("&#x26a0; Aucun périphérique GPU trouvé (CPU uniquement)")
   
    # Test de calcul simple
    a = tf.constant([1, 2, 3])
    b = tf.constant([4, 5, 6])
    c = tf.add(a, b)
    print(f"✓ Test de calcul de base : {a.numpy()} + {b.numpy()} = {c.numpy()}")
   
except ImportError as e:
    print(f"✗ Échec de l'importation de TensorFlow : {e}")

print("-" * 50)

# Vérifier les autres paquets importants
packages = ['numpy', 'pandas', 'matplotlib', 'sklearn', 'jupyter']
for package in packages:
    try:
        module = __import__(package)
        version = getattr(module, '__version__', 'inconnu')
        print(f"✓ {package}: {version}")
    except ImportError:
        print(f"✗ {package} : non installé")

print("-" * 50)

# Informations sur la mémoire et les appareils
print("Informations système :")
if tf.config.list_physical_devices('GPU'):
    for gpu in tf.config.list_physical_devices('GPU'):
        try:
            tf.config.experimental.set_memory_growth(gpu, True)
            print(f"✓ Croissance de la mémoire GPU activée pour {gpu}")
        except:
            print(f"&#x26a0; Impossible de définir la croissance de la mémoire pour {gpu}")

print("Vérification de l'installation terminée !")

Lancer la vérification :

python verify_installation.py

Test de performance

Créer un test de performance simple :

Exemple

import tensorflow as tf
import time

print("Test de performance TensorFlow")
print("-" * 30)

# Test de multiplication matricielle
def benchmark_matmul(device_name, size=1000):
    with tf.device(device_name):
        a = tf.random.normal([size, size])
        b = tf.random.normal([size, size])
       
        # Échauffement
        for _ in range(5):
            c = tf.matmul(a, b)
       
        # Chronométrage
        start_time = time.time()
        for _ in range(10):
            c = tf.matmul(a, b)
        end_time = time.time()
       
        avg_time = (end_time - start_time) / 10
        return avg_time

# Test CPU
cpu_time = benchmark_matmul('/CPU:0')
print(f"CPU ({1000}x{1000} matmul) : {cpu_time:.4f} secondes")

# Test GPU (si disponible)
if tf.config.list_physical_devices('GPU'):
    gpu_time = benchmark_matmul('/GPU:0')
    print(f"GPU ({1000}x{1000} matmul) : {gpu_time:.4f} secondes")
    print(f"Accélération GPU : {cpu_time/gpu_time:.2f}x")
else:
    print("Aucun GPU disponible pour les tests")

Problèmes courants et solutions

Problèmes d'installation

Problème 1 : expiration du délai d'installation de pip

pip install --user tensorflow

Problème 2 : erreur de permission

# 创建新的虚拟环境
python -m venv fresh_env
source fresh_env/bin/activate  # Linux/Mac
# ou  fresh_env\Scripts\activate  # Windows
pip install tensorflow

Problème 3 : conflit de versions

# 创建新的虚拟环境
python -m venv fresh_env
source fresh_env/bin/activate  # Linux/Mac
# ou  fresh_env\Scripts\activate  # Windows
pip install tensorflow

Problèmes liés au GPU

Problème 1 : incompatibilité de version CUDA

  • Vérifier la compatibilité des versions de TensorFlow et CUDA
  • Réinstaller la version CUDA correspondante

Problème 2 : mémoire GPU insuffisante

# 设置 GPU 内存增长
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
    for gpu in gpus:
        tf.config.experimental.set_memory_growth(gpu, True)

Problème 3 : GPU introuvable

# 检查 NVIDIA 驱动
nvidia-smi

# 检查 CUDA 安装
nvcc --version

# 重新安装 GPU 支持
pip uninstall tensorflow
pip install tensorflow

Problèmes liés à Jupyter

Problème 1 : environnement virtuel non visible dans Jupyter

# 安装 ipykernel
pip install ipykernel

# 添加虚拟环境到 Jupyter
python -m ipykernel install --user --name tensorflow_env --display-name "Python (TensorFlow)"

Problème 2 : Jupyter ne démarre pas

# 重新安装 Jupyter
pip uninstall jupyter notebook
pip install jupyter notebook

# 或使用 conda
conda install jupyter

Optimisation de l'environnement de développement

Gestion de la mémoire GPU

# GPU 配置优化
import tensorflow as tf

# 方法 1：设置内存增长
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)

# 方法 2：限制内存使用
if gpus:
    try:
        tf.config.experimental.set_memory_limit(gpus[0], 4096)  # 4GB
    except RuntimeError as e:
        print(e)

Paramètres d'optimisation des performances

# 启用混合精度训练（提升性能）
from tensorflow.keras.mixed_precision import experimental as mixed_precision

policy = mixed_precision.Policy('mixed_float16')
mixed_precision.set_policy(policy)

# 启用 XLA 编译优化
tf.config.optimizer.set_jit(True)

Configuration des outils de développement

Configuration de VS Code (.vscode/settings.json)：

{
    "python.defaultInterpreterPath": "./tensorflow_env/bin/python",
    "python.linting.enabled": true,
    "python.linting.pylintEnabled": true,
    "jupyter.defaultKernel": "tensorflow_env"
}

Maintenance de l'environnement

Mises à jour régulières

# 更新 TensorFlow
pip install --upgrade tensorflow

# 更新所有包
pip list --outdated
pip install --upgrade package_name

# 或批量更新
pip freeze | grep -v "^-e" | cut -d = -f 1 | xargs pip install -U

Sauvegarde et migration de l'environnement

# 导出环境
pip freeze > requirements.txt
conda env export > environment.yml

# 在新机器上恢复环境
pip install -r requirements.txt
conda env create -f environment.yml
Autres extensions