🎯 Projet Vision Transformer pour Configuration d'Antennes Circulaires

📋 Description du Projet

Ce projet utilise un Vision Transformer (ViT) pour résoudre un problème inverse en conception d'antennes : à partir d'une image représentant des spécifications de rayonnement (Gain, SLL, HPBW, θ₀), le modèle prédit la configuration optimale d'un réseau d'antennes circulaire (nombre d'antennes par anneau).

Objectif - Partie 1

L'objectif de cette première partie est de générer une seule configuration (un vecteur de 5 valeurs) pour une entrée donnée, en utilisant un encodeur ViT.

Spécifications Techniques

• Entrée : Image 224×224 représentant les spécifications

  • Gain du lobe principal (dB)
  • Niveau des lobes secondaires - SLL (dB)
  • Largeur du faisceau - HPBW (degrés)
  • Angle de pointage θ₀ (degrés)

• Sortie : Configuration d'antennes (5 valeurs)

  • Nombre d'antennes dans chaque anneau (5 anneaux maximum)
  • Chaque anneau peut contenir 0 à 10 antennes

---

📁 Structure du Projet

antenna_vit_project/
│
├── src/                          # Code source
│   ├── image_generator.py        # Génération d'images à partir des spécifications
│   ├── vit_model.py             # Architecture Vision Transformer
│   ├── vit_dataset.py           # Dataset PyTorch pour charger les données
│   ├── vit_training.py          # Script d'entraînement
│   └── vit_test.py              # Script de test et évaluation
│
├── data/                         # Données du projet
│   ├── Minput.npy               # Spécifications (4, nb_samples)
│   ├── Moutput.npy              # Configurations (5, nb_samples)
│   ├── Minput_training.npy      # Spécifications d'entraînement
│   ├── Moutput_training.npy     # Configurations d'entraînement
│   ├── Minput_test.npy          # Spécifications de test
│   ├── Moutput_test.npy         # Configurations de test
│   ├── training_images/         # Images d'entraînement générées
│   └── test_images/             # Images de test générées
│
├── models/                       # Modèles sauvegardés
│   ├── best_vit_antenna_model.pth      # Meilleur modèle
│   ├── final_vit_antenna_model.pth     # Modèle final
│   └── checkpoint_epoch_*.pth          # Checkpoints intermédiaires
│
└── results/                      # Résultats et visualisations
    ├── training_history.json    # Historique d'entraînement
    ├── training_history.png     # Courbes de perte
    ├── error_distribution.png   # Distribution des erreurs
    ├── predictions_vs_targets.png  # Prédictions vs valeurs réelles
    ├── prediction_examples.png  # Exemples de prédictions
    └── test_predictions.npz     # Prédictions complètes

---

🚀 Installation des Dépendances

1. Environnement Python

Assurez-vous d'avoir Python 3.8 ou supérieur installé.

2. Installer les packages requis

cd antenna_vit_project

# Installation des dépendances essentielles
pip install torch torchvision
pip install numpy matplotlib pillow tqdm

Dépendances complètes :

• torch (≥2.0) : Framework PyTorch
• torchvision : Pour le modèle ViT pré-entraîné
• numpy : Manipulation de données
• matplotlib : Visualisations
• pillow (PIL) : Traitement d'images
• tqdm : Barres de progression

---

📖 Guide d'Utilisation

Étape 0 : Préparer les données initiales

Prérequis : Vous devez d'abord exécuter les scripts originaux pour générer les données :

# Dans le dossier parent (ViT gen/)
python3 dataset.py                      # Génère Minput.npy et Moutput.npy
python3 repartition_training_test.py   # Divise en training/test

Ensuite, copier les fichiers .npy générés dans le dossier antenna_vit_project/data/ :

cp Minput_training.npy antenna_vit_project/data/
cp Moutput_training.npy antenna_vit_project/data/
cp Minput_test.npy antenna_vit_project/data/
cp Moutput_test.npy antenna_vit_project/data/

---

Étape 1 : Générer les Images

Convertir les spécifications numériques en images de diagrammes de rayonnement :

cd antenna_vit_project/src
python3 image_generator.py

Ce script va :

• Charger Minput_training.npy et Minput_test.npy
• Générer des images 224×224 pour chaque échantillon
• Sauvegarder dans data/training_images/ et data/test_images/

Sortie attendue :

🎨 Génération de XXXX images dans data/training_images
✅ XXXX images générées avec succès!
🎨 Génération de XXX images dans data/test_images
✅ XXX images générées avec succès!

---

Étape 2 : Entraîner le Modèle ViT

Lancer l'entraînement du Vision Transformer :

python3 vit_training.py

Configuration par défaut :

• Batch size : 16
• Epochs : 50
• Learning rate : 1e-4
• Optimizer : AdamW avec weight decay
• Scheduler : Cosine Annealing avec Warm Restarts
• Modèle : ViT-B/16 pré-entraîné sur ImageNet

Pendant l'entraînement, vous verrez :

Epoch   1/50 | Train Loss: 0.0234 | Val Loss: 0.0189 | Val MAE: 1.45 antennes
Epoch   2/50 | Train Loss: 0.0187 | Val Loss: 0.0156 | Val MAE: 1.23 antennes
   ⭐ Nouveau meilleur modèle sauvegardé (Val Loss: 0.0156)
...

Fichiers générés :

• models/best_vit_antenna_model.pth : Meilleur modèle (validation loss minimale)
• models/final_vit_antenna_model.pth : Modèle final
• results/training_history.json : Historique d'entraînement
• results/training_history.png : Courbes de perte et MAE

Temps d'entraînement estimé :

• CPU : ~2-4 heures (50 epochs)
• GPU : ~20-40 minutes (50 epochs)

---

Étape 3 : Tester et Évaluer le Modèle

Évaluer les performances du modèle sur l'ensemble de test :

python3 vit_test.py

Ce script va :

• Charger le meilleur modèle (best_vit_antenna_model.pth)
• Faire des prédictions sur l'ensemble de test
• Calculer les métriques de performance
• Générer des visualisations

Métriques calculées :

• MAE (Mean Absolute Error) par anneau et globale
• RMSE (Root Mean Squared Error)
• Pourcentage de prédictions exactes
• Pourcentage d'erreurs ≤ 1 antenne

Visualisations générées :

• error_distribution.png : Distribution des erreurs par anneau
• predictions_vs_targets.png : Scatter plots prédictions vs vraies valeurs
• prediction_examples.png : Exemples visuels de prédictions

Sortie attendue :

📊 MÉTRIQUES DE PERFORMANCE

🎯 Erreur Absolue Moyenne (MAE):
   Anneau 1: 0.85 antennes
   Anneau 2: 0.92 antennes
   ...
   Global:   0.88 antennes

✅ Prédictions Exactes (après arrondi):
   Anneau 1: 67.3%
   ...
   Global:   28.5% (toutes exactes)

---

🔧 Configuration Avancée

Modifier les Hyperparamètres

Éditez vit_training.py, section config :

config = {
    'batch_size': 16,          # Réduire si mémoire insuffisante
    'num_epochs': 50,          # Augmenter pour plus de convergence
    'learning_rate': 1e-4,     # Réduire si instabilité
    'weight_decay': 0.01,      # Régularisation L2
    'dropout': 0.1,            # Dropout pour éviter le surapprentissage
    'freeze_encoder': False,   # True = entraîner seulement la tête
    'num_workers': 2           # Parallélisme du chargement
}

Transfer Learning en Deux Étapes

Étape 1 : Entraîner seulement la tête

config['freeze_encoder'] = True
config['num_epochs'] = 10
config['learning_rate'] = 1e-3

Étape 2 : Fine-tuning complet

config['freeze_encoder'] = False
config['num_epochs'] = 40
config['learning_rate'] = 1e-5

---

📊 Comparaison FFNN vs ViT

Critère	FFNN (Ancien)	ViT (Nouveau)
Entrée	Vecteur 4D	Image 224×224
Paramètres	~500	~85 millions
Pré-entraînement	Non	Oui (ImageNet)
Interprétabilité	Faible	Moyenne (attention maps)
Temps d'entraînement	Court (~minutes)	Long (~heures)
Extensibilité	Limitée	Excellente

---

🐛 Résolution de Problèmes

Erreur : "Import torch could not be resolved"

pip install torch torchvision

Erreur : "Image introuvable"

Assurez-vous d'avoir exécuté image_generator.py avant l'entraînement.

Erreur : "CUDA out of memory"

Réduisez le batch_size dans vit_training.py :

config['batch_size'] = 8  # ou 4

Performances faibles

• Augmentez le nombre d'epochs (100 au lieu de 50)
• Essayez le mode freeze_encoder=True d'abord
• Vérifiez la qualité des images générées

---

📈 Partie 2 (Future)

La partie 2 du projet visera à générer plusieurs configurations pour une même entrée, en utilisant des approches génératives (VAE, GAN, ou Diffusion Models).

Idées pour la Partie 2 :

• Utiliser un décodeur variational après l'encodeur ViT
• Générer plusieurs vecteurs de configuration avec diversité
• Ajouter une contrainte de validité physique

---

📚 Références

• Vision Transformer (ViT) : Dosovitskiy et al., 2021
• PyTorch Vision : Documentation officielle

---

👨‍💻 Auteurs

Projet développé dans le cadre d'une application de conception d'antennes par apprentissage profond.

---

📝 Notes

• Les erreurs de linting (imports non résolus) sont normales avant l'installation des packages
• Le téléchargement du modèle ViT pré-entraîné (~330 MB) se fera automatiquement au premier lancement
• Pour un entraînement plus rapide, utilisez un GPU (CUDA)

---

✅ Bon développement avec votre projet ViT ! 🚀