pix2pix repose sur Torch, un framework d'apprentissage automatique open source utilisant le langage Lua. Torch est réputé pour son calcul tensoriel efficace et sa riche bibliothèque de réseaux de neurones, particulièrement adopté aux tâches de vision par ordinateur. Cete section détaille l'installation correcte de Torch et de ses dépendances pour garantir le bon fonctionnement de pix2pix.

Prérequis système

Composant	Minimum	Recommandé
Système d'exploitation	Linux ou macOS	Ubuntu 18.04+ ou macOS 10.14+
Processeur	CPU 64 bits multicœur	8 cœurs ou plus
Mémoire	8 Go RAM	16 Go RAM ou plus
Carte graphique	Intégrée	GPU NVIDIA + CUDA
Espace disque	10 Go	20 Go ou plus

Procédure d'installation de Torch

L'installation se fait via un script officiel :

# Installation des dépendances système
sudo apt-get update
sudo apt-get install -y git curl cmake build-essential g++ gcc make \
    libreadline-dev libjpeg-dev libpng-dev libncurses5-dev \
    libzmq3-dev libgflags-dev libgoogle-glog-dev libhdf5-serial-dev

# Clone et installation de Torch
git clone https://github.com/torch/distro.git ~/torch --recursive
cd ~/torch
bash install-deps
./install.sh

Ajoutez Torch au PATH :

echo 'source ~/torch/install/bin/torch-activate' >> ~/.bashrc
source ~/.bashrc

Installation des paquets clés

Les paquets suivants sont indispensables pour pix2pix :

luarocks install nngraph
luarocks install https://raw.githubusercontent.com/szym/display/master/display-scm-0.rockspec
luarocks install image
luarocks install optim
luarocks install nn
luarocks install cutorch   # Support CUDA (si GPU disponible)
luarocks install cunn      # Support CUDA pour réseaux de neurones

Configuration CUDA et cuDNN (optionnelle mais recommandée)

# Vérifier si CUDA est installé
nvcc --version

# Si CUDA n'est pas installé, téléchargez-le depuis NVIDIA.
# Ensuite, recompilez Torch avec le support CUDA :
cd ~/torch
./clean.sh
TORCH_NVCC_FLAGS="-D__CUDA_NO_HALF_OPERATORS__" ./install.sh

Vérification de l'installation

Créez un script de test :

-- test_torch.lua
require 'torch'
require 'nn'
require 'nngraph'
require 'image'

print('Version Torch :', torch.__version__)
print('CUDA disponible :', pcall(function() require 'cutorch' end))

-- Opération tensorielle
x = torch.Tensor(5, 3):normal(0, 1)
print('Tenseur créé, dimensions :', x:size())

-- Modèle simple
model = nn.Sequential()
model:add(nn.Linear(10, 5))
model:add(nn.Tanh())
model:add(nn.Linear(5, 1))
print('Modèle créé avec succès')

Exécutez : th test_torch.lua

Problèmes courants et solutions

Problème	Cause probable	Solution
Commande luarocks introuvable	Environnement Torch non activé	source ~/torch/install/bin/torch-activate
Erreur CUDA	CUDA non installé ou version incompatible	Vérifier la version CUDA et recompiler Torch
Mémoire insuffisante	RAM limitée	Augmenter le swap ou réduire le batch size
Échec de téléchargement	Problème réseau	Utiliser un miroir local ou télécharger manuellement

Bonnes pratiques

1. Utiliser un environnement virtuel (Docker, conda) pour éviter les conflits.
2. Mettre à jour régulièrement Torch et ses paquets.
3. Documenter la configuration réussie pour la reproduire sur d'autres machines.
4. Surveiller l'utilisation GPU/mémoire pendant l'entraînement.

Présentation des six jeux de données standard

pix2pix fournit six jeux de données organisés pour différentes tâches de translation d'image à image.

Vue d'ensemble

Nom	Nombre d'images	Application principale	Source	Sens de translation
facades	400	Génération de façades	CMP Facades	étiquette ↔ image réelle
cityscapes	2 975	Segmentation sémantique de rues	Cityscapes	étiquette ↔ image urbaine
maps	1 096	Conversion de styles cartographiques	Google Maps	satellite ↔ carte
edges2shoes	50 000	Génération d'images de chaussures	UT Zappos50K	contours ↔ photo
edges2handbags	137 000	Génération de sacs à main	Amazon Handbags	contours ↔ photo
night2day	20 000	Conversion nuit/jour	Transient Attributes	nuit ↔ jour

Détails par jeu

1. Facades

400 images de façades issues de CMP Facades, pour générer des façades à partir d'étiquettes sémantiques. Images uniformisées, adaptées à l'apprentissage sur petits échantillons.

2. Cityscapes

2 975 images de rues prises dans plusieurs villes allemandes. Translation bidirectionnelle possible.

class CityscapesDataset:
    def __init__(self, data_path):
        self.data_path = data_path
        self.train_ids = self._load_split_ids('train')
        self.val_ids = self._load_split_ids('val')

    def load_image(self, split, city, idx):
        img_path = f"{self.data_path}/{split}/{city}/{idx}_leftImg8bit.png"
        return self._load_image(img_path)

3. Maps

1 096 paires satellite/carte récoltées via Google Maps.

4. Edges2Shoes

50 000 images de chaussures (UT Zappos50K). Les contours sont extraits avec l'algorithme HED.

5. Edges2Handbags

137 000 images de sacs à main (Amazon). Utilise également HED.

6. Night2Day

Environ 20 000 scènes naturelles de Transient Attributes, conversion jour/nuit.

Téléchargement

bash ./datasets/download_dataset.sh <nom_dataset>
# Exemples :
bash ./datasets/download_dataset.sh facades
bash ./datasets/download_dataset.sh cityscapes

Les données sont extraites dans ./datasets/ avec la structure originale.

Prétraitement

• Images redimensionnées à 256×256.
• Correspondance stricte entre les paires.
• Augmentation de données standard.
• Séparation entraînement/validation/test.

Citation académique

N'oubliez pas de citer les auteurs des jeux de données originaux (Tyleček et al. 2013 pour facades, Cordts et al. 2016 pour cityscapes, etc.).

Préparation et mise en forme d'un jeu de données personnalisé

Pour utiliser vos propres données avec pix2pix, vous devez respecter une structure spécifique et appliquer un prétraitement adapté.

Structure de répertoires

Créez deux dossiers A et B contenant respectivement les images source et cible, avec les sous-dossiers train/val/test :

/chemin/vers/mon_dataset/
├── A/
│   ├── train/
│   │   ├── img001.jpg
│   │   ├── img002.jpg
│   │   └── ...
│   ├── val/
│   └── test/
└── B/
    ├── train/
    ├── val/
    └── test/

Les noms de fichiers doivent correspondre entre A et B (ex: A/train/img001.jpg ↔ B/train/img001.jpg).

Options de prétraitement

Utilisez le paramètre preprocess :

-- Prétraitement standard
opt.preprocess = 'regular'

-- Colorisation
opt.preprocess = 'colorization'

-- Inpainting
opt.preprocess = 'inpaint'

Script combine_A_and_B.py

Ce script concatène horizontalement chaque paire d'images :

python scripts/combine_A_and_B.py \
    --fold_A /chemin/vers/mon_dataset/A \
    --fold_B /chemin/vers/mon_dataset/B \
    --fold_AB /chemin/vers/combined_dataset

Paramètres disponibles :

Argument	Description	Valeur par défaut
--fold_A	Chemin du dossier A	../dataset/50kshoes_edges
--fold_B	Chemin du dossier B	../dataset/50kshoes_jpg
--fold_AB	Chemin de sortie	../dataset/test_AB
--num_imgs	Nombre d'images à traiter	1000000
--use_AB	Utiliser la convention _A/_B	False

Préparation des contours pour edges2something

Pour les tâches de type contours→image, utilisez le détecteur HED :

# Extraction des contours HED
python scripts/edges/batch_hed.py \
    --images_dir /chemin/vers/photos/ \
    --hed_mat_dir /chemin/vers/fichiers_mat/

# Post-traitement MATLAB
matlab -nodisplay -r "PostprocessHED('/chemin/vers/hed_mat/', '/chemin/vers/sortie/', 256, 0.1, 5); exit;"

Le pipeline inclut : extraction HED, suppression non-maxima, seuillage, nettoyage des petits contours.

Augmentation de données

pix2pix intègre plusieurs techniques d'augmentation :

-- Active le retournement horizontal aléatoire
opt.flip = 1

-- Dimensions de chargement et de rognage
opt.loadSize = 286
opt.fineSize = 256

-- Normalisation des images dans [-1, 1]

Exemple d'implémentation en Lua :

-- Rognage aléatoire
local function randomCrop(im, oW, oH)
    local iH = im:size(2)
    local iW = im:size(3)
    local h1, w1 = 0, 0
    if iH ~= oH then h1 = math.ceil(torch.uniform(1e-2, iH - oH)) end
    if iW ~= oW then w1 = math.ceil(torch.uniform(1e-2, iW - oW)) end
    return image.crop(im, w1, h1, w1 + oW, h1 + oH)
end

-- Retournement horizontal aléatoire
if opt.flip == 1 and torch.uniform() > 0.5 then
    imA = image.hflip(imA)
    imB = image.hflip(imB)
end

Format et dimensions des images

Propriété	Valeur recommandée	Notes
Format	JPEG/PNG	Formats courants supportés
Dimentions	256×256	Taille standard pour l'entraînement
Espace colorimétrique	RGB	Trois canaux
Nom des fichiers	Correspondant	Même nom dans A et B

Vérification de l'intégrité

# Vérifier la correspondance des fichiers
python -c "
import os
fold_A = '/chemin/vers/A/train'
fold_B = '/chemin/vers/B/train'
files_A = set([f for f in os.listdir(fold_A) if f.endswith(('.jpg','.png'))])
files_B = set([f for f in os.listdir(fold_B) if f.endswith(('.jpg','.png'))])
print('Fichiers dans A mais pas dans B:', files_A - files_B)
print('Fichiers dans B mais pas dans A:', files_B - files_A)
print('Nombre de fichiers communs:', len(files_A & files_B))
"

# Vérifier les dimensions
python -c "
from PIL import Image
import os
fold_A = '/chemin/vers/A/train'
for f in os.listdir(fold_A)[:10]:
    img = Image.open(os.path.join(fold_A, f))
    print(f, img.size)
"