Comment apprendre le quantum machine learning sur GitHub ?

En combinant cartographie, lectures scientifiques, notebooks Python, projets sur machines NISQ et Qiskit. Le vrai enjeu n’est pas de collectionner des dépôts GitHub, mais de suivre une progression claire pour comprendre, tester et industrialiser le quantum machine learning sans brûler les étapes.

Par où commencer sans se perdre ?

Il faut commencer par cartographier le domaine avec une liste structurée comme awesome-quantum-machine-learning, plutôt que lancer immédiatement du code. Le quantum machine learning, ou apprentissage automatique quantique, couvre deux directions proches : utiliser des méthodes quantiques pour résoudre des tâches de machine learning, ou utiliser le machine learning pour analyser, contrôler ou simuler des systèmes quantiques.

Quelques mots reviennent vite, et mieux vaut les poser dès le départ. Un qubit est l’unité d’information quantique, l’équivalent du bit classique, mais avec des propriétés comme la superposition. Un circuit quantique est une suite d’opérations appliquées à des qubits. Un kernel quantique sert à comparer des données après les avoir projetées dans un espace quantique. Un circuit variationnel est un circuit avec des paramètres ajustables, souvent optimisés par un ordinateur classique. Le terme NISQ signifie Noisy Intermediate-Scale Quantum : il désigne les ordinateurs quantiques actuels, encore bruités, limités en nombre de qubits et sensibles aux erreurs.

Le dépôt awesome-quantum-machine-learning fonctionne comme une table des matières du domaine. Sa licence CC0-1.0 le place dans le domaine public autant que possible, ce qui facilite sa réutilisation. Pour débuter, son intérêt est simple : éviter l’éparpillement. Au lieu d’ouvrir dix dépôts GitHub au hasard, vous repérez les grandes familles de ressources : bases mathématiques, algorithmes, bibliothèques, notebooks, papiers scientifiques et sujets voisins.

Deux repères solides aident à garder le contexte. L’article Quantum machine learning de Biamonte et al., publié dans Nature en 2017, situe les grandes promesses et familles d’approches du domaine. L’article de John Preskill, Quantum Computing in the NISQ era and beyond, publié dans Quantum en 2018, explique pourquoi les machines actuelles restent expérimentales et pourquoi les résultats doivent être lus avec prudence.

Type de ressource	Ce qu’il faut repérer
Bases théoriques	Algèbre linéaire, probabilités, mécanique quantique minimale.
Algorithmes	Kernels quantiques, circuits variationnels, classification, optimisation.
Frameworks	Qiskit, PennyLane, Cirq, outils de simulation et d’exécution.
Notebooks	Exemples reproductibles, petits jeux de données, code commenté.
Articles scientifiques	Résultats évalués par les pairs, limites, hypothèses expérimentales.
Contraintes matérielles	Bruit, nombre de qubits, profondeur des circuits, limites NISQ.

Quels articles lire en priorité ?

Il faut ensuite utiliser awesome-quantum-ml pour sélectionner des lectures plus ciblées, surtout si les bases sont déjà comprises.

Ce dépôt GitHub est plus court que les grandes listes généralistes et davantage orienté recherche. Je le vois comme un outil de bibliographie : articles scientifiques, surveys, ressources de qualité, travaux fondateurs et pistes d’approfondissement. Un survey est un article de synthèse qui résume l’état d’un domaine, compare les approches et donne souvent une bonne carte des débats ouverts.

Après la cartographie générale, l’objectif est de passer du repérage à la compréhension des concepts qui reviennent partout dans le quantum machine learning, ou QML : kernels quantiques, réseaux neuronaux quantiques, circuits variationnels, encodage des données classiques dans un circuit quantique et mesure des résultats. Un kernel quantique sert à comparer des données après les avoir projetées dans un espace quantique. Un circuit variationnel est un circuit paramétré que l’on optimise avec une boucle classique, un peu comme l’entraînement d’un modèle de machine learning classique.

La méthode de lecture doit rester simple. Commencez par les surveys, puis notez les concepts qui reviennent dans plusieurs articles. Identifiez aussi les bibliothèques utilisées, par exemple Qiskit, PennyLane ou Cirq. Vérifiez ensuite si les expériences sont seulement simulées ou exécutées sur du matériel quantique réel. Cette distinction compte, car les machines actuelles sont bruitées et limitées en nombre de qubits fiables.

Il ne faut pas survendre le QML. La recherche avance vite, mais l’avantage quantique utile en production reste un sujet ouvert dans la littérature scientifique. John Preskill l’a formulé clairement en 2018 avec l’ère NISQ, pour “Noisy Intermediate-Scale Quantum” : des processeurs quantiques intermédiaires, prometteurs, mais encore sensibles au bruit et aux erreurs. Les documents IBM Qiskit vont dans le même sens côté pratique : les usages actuels passent souvent par des simulateurs, des circuits courts, des backends réels contraints et une forte attention portée au bruit matériel.

Pour classer les articles, gardez les critères suivants :

• Clarté du problème traité.
• Code disponible.
• Protocole expérimental reproductible.
• Comparaison avec des modèles classiques.
• Prise en compte du bruit matériel.

Comment passer de la théorie au code ?

Il faut exécuter des notebooks guidés, modifier les paramètres et observer les résultats, par exemple avec Hands-On-Quantum-Machine-Learning-With-Python-Vol-1. Ce dépôt correspond au code associé au livre Hands-On Quantum Machine Learning With Python Vol 1. Sa structure en notebooks et scripts permet de suivre les chapitres, de lancer des expériences, puis de changer progressivement les paramètres sans repartir de zéro.

Un notebook est un document interactif qui mélange texte, code et résultats dans le même fichier. C’est très utile en QML, ou quantum machine learning, car chaque étape devient visible : préparation des données, encodage dans un circuit quantique, choix du modèle, entraînement, mesure, puis interprétation. Un script, lui, est un fichier de code plus classique, souvent utilisé pour automatiser une expérience. Une simulation consiste à exécuter un circuit quantique sur un ordinateur classique. Un backend désigne l’environnement d’exécution : simulateur local, simulateur cloud ou vrai processeur quantique.

La bonne routine est simple, mais exigeante. D’abord, exécuter le notebook sans modification pour vérifier que tout fonctionne. Ensuite, changer un seul paramètre à la fois : nombre de qubits, profondeur du circuit, taux d’apprentissage, nombre d’itérations. Puis noter les effets observés, comparer la performance avec un modèle classique simple, et seulement après tenter une petite variation sur un jeu de données facile à comprendre.

# Pseudo-code simplifié, sans reproduire exactement le dépôt

donnees = charger_donnees("jeu_simple")
entrainement, test = separer_donnees(donnees, graine=42)

circuit = definir_circuit_quantique(
    qubits=4,
    profondeur=2,
    encodage="angle"
)

modele = entrainer_modele(
    circuit=circuit,
    donnees=entrainement,
    iterations=100
)

score = evaluer_modele(modele, test)
afficher(score)

Les lectures donnent le vocabulaire : qubit, superposition, intrication, mesure, circuit variationnel. Les notebooks construisent l’intuition expérimentale. Les deux sont nécessaires, mais ils ne jouent pas le même rôle. Sans carnet de résultats, vous risquez de confondre une impression avec une preuve. Notez la configuration, la graine aléatoire, le score, le temps d’exécution et le backend utilisé.

Erreur fréquente	Pourquoi c’est un problème	Bon réflexe
Changer trop de paramètres	Impossible de savoir ce qui améliore ou dégrade le résultat.	Modifier un seul paramètre par expérience.
Ignorer le modèle classique de comparaison	Un modèle quantique peut sembler intéressant alors qu’un modèle simple fait mieux.	Comparer avec une régression logistique, un SVM ou un arbre de décision.
Ne pas fixer de graine aléatoire	Les résultats deviennent difficiles à reproduire.	Définir une graine, par exemple 42, dans chaque expérience.
Ne pas distinguer simulateur et matériel réel	Le bruit, les temps d’attente et les erreurs ne sont pas les mêmes.	Indiquer clairement le backend utilisé.

Que valent les projets sur machines actuelles ?

Les projets sur machines actuelles servent surtout à comprendre les contraintes réelles du QML, pas à promettre un avantage quantique immédiat.

Après les notebooks guidés, un dépôt comme Quantum-Machine-Learning-on-Near-Term-Quantum-Devices force à quitter le confort des exemples propres. Il se concentre sur les dispositifs quantiques proches du présent, souvent appelés NISQ, pour Noisy Intermediate-Scale Quantum. En clair : des machines quantiques déjà utilisables pour expérimenter, mais encore limitées par le bruit, les erreurs de mesure, la profondeur des circuits et le nombre de qubits disponibles. John Preskill a popularisé ce cadre en 2018 dans son article Quantum Computing in the NISQ era and beyond, une bonne référence pour comprendre pourquoi cette période est utile, mais fragile.

Le dépôt permet de manipuler plusieurs familles de modèles. Les SVM quantiques, pour Support Vector Machine, cherchent une frontière de décision entre plusieurs classes, par exemple séparer deux types de points dans un espace de données. Les réseaux convolutionnels quantiques reprennent l’idée des convolutions utilisées en vision par ordinateur, mais avec des circuits quantiques qui extraient des motifs à petite échelle. Les modèles de re-uploading, eux, réinjectent plusieurs fois les mêmes données dans un circuit afin d’augmenter son expressivité, c’est-à-dire sa capacité à représenter des relations plus complexes.

Avant de lancer ce type de projet, je vérifie toujours quelques points simples :

• Objectif de classification : Définir clairement les classes à prédire et éviter les problèmes trop artificiels.
• Baseline classique : Comparer avec un modèle classique simple, comme une régression logistique, un SVM standard ou un petit réseau de neurones.
• Métrique : Choisir une mesure lisible, par exemple accuracy, F1-score ou matrice de confusion.
• Taille du circuit : Surveiller le nombre de qubits, le nombre de portes et la profondeur du circuit.
• Backend : Préciser si l’exécution se fait sur simulateur ou sur hardware réel, c’est-à-dire une vraie machine quantique.
• Bruit : Mesurer l’impact des erreurs de portes, des erreurs de lecture et de la décohérence.
• Reproductibilité : Fixer les graines aléatoires, documenter les versions des librairies et conserver les paramètres d’entraînement.

La vraie valeur de ces projets est là : apprendre à interpréter des résultats imparfaits. Les jeux de données sont souvent petits, les simulations coûtent cher dès que le nombre de qubits augmente, et les écarts entre simulateur et hardware réel peuvent être importants. Sans baseline classique solide, il devient très facile de confondre expérimentation intéressante et performance réellement utile.

Quel outil choisir pour construire un pipeline ?

Pour construire des pipelines QML plus robustes, qiskit-machine-learning est le choix le plus structurant parmi les dépôts présentés.

Un pipeline est une chaîne reproductible d’étapes : données, transformation, modèle, entraînement, évaluation, puis déploiement ou réutilisation. Dans un contexte QML, pour Quantum Machine Learning, l’enjeu n’est pas de promettre une industrialisation immédiate partout, mais de rendre les expériences propres, comparables et extensibles.

La bibliothèque qiskit-machine-learning est intégrée à l’écosystème Qiskit, co-maintenue par IBM et le Hartree Centre. Elle fournit des composants pour kernels quantiques, réseaux neuronaux quantiques, classifieurs, régresseurs et intégration avec PyTorch via TorchConnector. C’est utile si vous voulez passer du notebook isolé à un workflow que vous pouvez relancer, modifier et comparer sérieusement.

Les briques principales sont assez simples à situer :

• Un kernel quantique mesure une forme de similarité entre données après encodage dans un circuit quantique.
• Un réseau neuronal quantique combine des circuits paramétrés avec une méthode d’optimisation classique.
• TorchConnector permet de connecter certains modèles Qiskit à PyTorch, pour travailler dans un environnement machine learning plus familier.

Dans le parcours d’apprentissage, chaque ressource a son rôle. Les listes awesome servent à explorer, les articles à comprendre, les notebooks à pratiquer, les projets NISQ à tester les limites des machines quantiques actuelles bruitées, puis Qiskit à structurer des workflows réutilisables.

Un mini pipeline conceptuel peut ressembler à ceci :

# Préparation des données
X_train, X_test, y_train, y_test = split_dataset(data, labels)

# Transformation quantique des variables
feature_map = build_quantum_feature_map(num_features=4)

# Modèle QML
model = QuantumClassifier(feature_map=feature_map)

# Entraînement
model.fit(X_train, y_train)

# Évaluation
accuracy = model.score(X_test, y_test)
print(accuracy)

Ce choix a surtout une valeur professionnelle : apprendre à construire des expérimentations traçables, avec des métriques, des paramètres et des modèles que vous pouvez comparer. La documentation officielle Qiskit Machine Learning reste la source principale pour les API, les classifieurs, les régresseurs, les kernels et TorchConnector.

Dépôt	Rôle	Niveau	Livrable attendu
Listes awesome QML	Explorer les ressources fiables	Débutant	Carte personnelle des sujets à creuser
Articles et papers	Comprendre les concepts	Débutant à intermédiaire	Notes synthétiques et définitions claires
Notebooks QML	Pratiquer sur exemples	Intermédiaire	Notebook exécuté et modifié
Projets NISQ	Tester les limites matérielles	Intermédiaire à avancé	Comparaison simulateur contre backend bruité
qiskit-machine-learning	Structurer un pipeline réutilisable	Avancé	Workflow QML entraînable, évalué et documenté

Alors par quel dépôt commencer maintenant ?

Le bon parcours commence par une vue d’ensemble, se poursuit avec des lectures ciblées, puis passe vite à l’expérimentation. Les listes awesome aident à structurer le domaine, les notebooks Python transforment les concepts en gestes concrets, les projets NISQ montrent les limites du matériel actuel, et qiskit-machine-learning donne un cadre plus solide pour construire des pipelines. Le quantum machine learning reste un sujet de recherche exigeant, pas une recette magique. En suivant cette progression, vous gagnez du temps, vous évitez les dépôts isolés sans méthode et vous construisez une compétence QML plus fiable.

FAQ

• Qu’est-ce que le quantum machine learning ?
  Le quantum machine learning, ou QML, regroupe les méthodes qui utilisent des concepts du calcul quantique pour traiter des problèmes d’apprentissage automatique. Il peut aussi inclure l’usage du machine learning pour résoudre des problèmes liés aux systèmes quantiques. Le domaine reste très expérimental, surtout sur les machines actuelles dites NISQ.
• Faut-il connaître la physique quantique pour commencer ?
  Il faut au minimum comprendre les notions de qubit, superposition, mesure, circuit quantique et bruit. En revanche, il n’est pas nécessaire de commencer par un niveau avancé en physique théorique. Un bon parcours consiste à apprendre les concepts essentiels, puis à les manipuler dans des notebooks Python.
• Pourquoi utiliser GitHub pour apprendre le QML ?
  GitHub permet d’accéder à des listes de ressources, du code exécutable, des notebooks, des exemples de projets et des bibliothèques comme qiskit-machine-learning. C’est utile pour passer de la lecture à l’expérimentation, à condition de suivre une progression claire et de vérifier la qualité des dépôts.
• Quel dépôt GitHub choisir en premier ?
  Pour débuter, une liste comme awesome-quantum-machine-learning est le meilleur point d’entrée, car elle donne une vision structurée du domaine. Ensuite, awesome-quantum-ml aide à sélectionner les lectures scientifiques, avant de passer aux notebooks pratiques et aux projets plus proches du matériel réel.
• Qiskit est-il indispensable pour apprendre le quantum machine learning ?
  Qiskit n’est pas le seul outil possible, mais qiskit-machine-learning est une bibliothèque solide pour construire des pipelines QML avec kernels quantiques, réseaux neuronaux quantiques, classifieurs, régresseurs et intégration PyTorch via TorchConnector. C’est un bon choix quand l’objectif dépasse le simple test de notebooks.

 

 

A propos de l’auteur

Je suis Franck Scandolera, responsable de l’agence webAnalyste et de l’organisme Formations Analytics. J’accompagne les entreprises sur le tracking avancé server-side, l’analytics engineering, l’automatisation No/Low Code avec n8n, l’intégration de l’IA, le SEO et la GEO. J’ai travaillé pour des clients comme Logis Hôtel, Yelloh Village, BazarChic, la Fédération Française de Football ou Texdecor. Si vous voulez structurer vos données, automatiser vos workflows ou intégrer l’IA dans vos équipes, vous pouvez me contacter.