Python est un langage de programmation généraliste, mais il n’est pas suffisant pour gérer efficacement les opérations complexes et massivement parallèles du Deep Learning. TensorFlow et PyTorch sont conçus pour optimiser ces calculs et faciliter la création, l'entraînement et le déploiement de réseaux de neurones.

  1. Problèmes avec une implémentation "pure" en Python

Si on utilisait uniquement Python (sans TensorFlow/PyTorch), on rencontrerait plusieurs problèmes :

 1.1 Performances limitées (Pas d'optimisation pour le GPU)

  • Les opérations matricielles sont au cœur du Deep Learning.
  • Python utilise par défaut NumPy, qui est performant mais ne gère pas bien les GPUs.
  • TensorFlow/PyTorch exploitent CUDA et cuDNN pour exécuter les calculs massivement en parallèle sur GPU.

Exemple avec NumPy (sans GPU) :

 

import numpy as np

 A = np.random.rand(1000, 1000)

B = np.random.rand(1000, 1000)

C = np.dot(A, B)  # Multiplication matricielle (CPU uniquement)

 

Problème : Ce code fonctionne bien mais ne peut pas tirer parti du GPU.

Avec PyTorch (optimisé pour GPU) :

 

import torch

A = torch.rand(1000, 1000, device="cuda")  # Stocké sur le GPU

B = torch.rand(1000, 1000, device="cuda")

 

C = torch.matmul(A, B)  # Multiplication sur GPU

Avantage : Exécution beaucoup plus rapide grâce au GPU.

1.2 Pas de gestion automatique du graphe de calcul

  • En Python pur, il faudrait coder manuellement la rétropropagation (backpropagation).
  • TensorFlow et PyTorch créent et optimisent le graphe de calcul automatiquement.

Exemple sans framework (backpropagation manuelle) :

# Calcul d'un simple neurone

w = 0.5  # Poids

x = 2.0  # Entrée

y_true = 1.0  # Sortie attendue

learning_rate = 0.01

 

# Forward pass

y_pred = w * x 

loss = (y_pred - y_true) ** 2  # Erreur quadratique

 

# Backpropagation (calcul du gradient)

grad = 2 * (y_pred - y_true) * x  # Dérivée de la loss

w -= learning_rate * grad  # Mise à jour du poids

print(w)  # Poids ajusté

 

 Problème :

  • Il faut manuellement dériver et implémenter la descente de gradient.
  • Pour un réseau profond (CNN, Transformer), c'est impraticable.

Avec PyTorch (rétropropagation automatique) :

 

import torch

w = torch.tensor(0.5, requires_grad=True)  # Activation du calcul du gradient

x = torch.tensor(2.0)

y_true = torch.tensor(1.0)

 

y_pred = w * x

loss = (y_pred - y_true) ** 2

 

loss.backward()  # Calcul automatique du gradient

print(w.grad)  # Affiche le gradient

Avantage :

  • Pas besoin de calculer manuellement les dérivées.
  • La rétropropagation est automatique et optimisée.

1.3 Pas d'intégration facile avec des modèles pré-entraînés

  • PyTorch et TensorFlow offrent des modèles pré-entraînés pour éviter de repartir de zéro.
  • Python seul ne propose aucune bibliothèque standard pour charger des modèles existants.

Exemple : Charger un modèle ResNet pré-entraîné en PyTorch

 

import torch

import torchvision.models as models

model = models.resnet18(pretrained=True)  # Chargement du modèle ResNet

model.eval()  # Mode évaluation (désactive le dropout)

 

 Avantage : En quelques lignes, on charge un modèle performant.
 Problème avec Python seul : Il faudrait coder tout le réseau ResNet à la main.

1.4 Difficulté à gérer le Data Loading et l’optimisation

Les frameworks offrent :

  • Gestion automatique des datasets (ImageNet, CIFAR-10, MNIST, etc.).
  • Chargement efficace des données avec DataLoader et prétraitement parallèle.

Exemple : Chargement d'images avec PyTorch

 

from torchvision import datasets, transforms

from torch.utils.data import DataLoader

 

# Transformation et normalisation des images

transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

 

# Chargement du dataset MNIST

train_data = datasets.MNIST(root="./data", train=True, transform=transform, download=True)

train_loader = DataLoader(train_data, batch_size=32, shuffle=True)

 

 Avantage : Chargement rapide et efficace des images.
 Problème avec Python seul : Il faudrait coder un système de chargement manuellement, ce qui est inefficace.

  1. Résumé : Pourquoi PyTorch/TensorFlow et pas juste Python ?

Problème

Python Pur

TensorFlow/PyTorch

Optimisation GPU

❌ Non

⇒ Oui (CUDA/cuDNN)

Rétropropagation

❌ Manuelle

⇒    Automatique

Chargement de données

❌ Manuel

⇒    DataLoader intégré

Utilisation de modèles pré-entraînés

❌ Impossible

⇒    Facile

Optimisation du graphe

❌ Non

⇒    Oui (exécutions rapides)

 

 Python seul est trop bas niveau pour entraîner des modèles Deep Learning efficacement.
 TensorFlow et PyTorch apportent :

  • Une accélération GPU (jusqu'à 100x plus rapide).
  • Une gestion automatique des gradients.
  • Un chargement de données efficace.
  • Une intégration avec des modèles pré-entraînés.