Texte intégral 2338 Mots, durée estimée de l'étude 13 Procès-verbaux
Source: unsplash
En octobre de l'année dernière, "Nature" a publié un article de Google. Son processeur quantique Sycammore peut terminer le calcul de dizaines de milliers d'années de superordinateurs traditionnels en 200 secondes. Sur cette base, Google prétend atteindre une "hégémonie quantique" .
Le 9 mars 2020, Google Artificial Intelligence a confirmé la disponibilité de TensorFlow Quantum (TFQ), une bibliothèque open source pour développer rapidement des modèles d'apprentissage automatique quantique. Est-ce une nouvelle astuce de "l'hégémonie quantique" de Google?
En fait, il y avait plusieurs autres cadres comme Pennylane plus tôt, mais aucun n'était aussi bon que TFQ. TFQ apparaît dans ce champ comme une boîte à outils et n'est toujours pas public. L'auteur a découvert certains autres cadres, mais après avoir étudié TFQ, il est indéniable que TFQ est le meilleur.
Comment effectuer un apprentissage automatique sur des circuits quantiques paramétriques?
Pour clarifier cela, le directeur technique de TFQ, Massoud Mosini, en a donné un exemple. Il a déclaré: "Il convient de noter que le fonctionnement unitaire ou la rotation aléatoire imprimée dans le corps espace-temps est une rotation paramétrée continue qui imite les circuits classiques, tels que le mappage entrée-sortie dans les réseaux neuronaux profonds"
Source: unsplash
C'est le principe des réseaux neuronaux quantiques.
Mais comment créer ces circuits quantiques paramétrés?
La première étape dans le développement d'un modèle quantique hybride est de pouvoir utiliser l'informatique quantique. Pour cela, TFQ s'appuie sur Cirq (une plateforme open source pour les circuits quantiques sur les ordinateurs récents).
Cirq comprend la définition des structures de base nécessaires à l'informatique quantique, telles que les qubits, les portes, les circuits et les opérateurs de calcul. L'idée derrière Cirq est de fournir un modèle de programmation simple qui résume les blocs de construction de base des applications quantiques.
Pouvez-vous combiner cirq et TFQ? Quels sont les défis?
Obstacle technique 1
· Impossible d'importer des données quantiques.
· Les données et les modèles sont des couches dans des circuits quantiques.
· Les données quantiques doivent être préparées en tout temps.
Obstacle technique 2
· CPU-QPU à latence relativement élevée.
· Les travaux par lots sont relayés vers des ordinateurs quantiques.
· Un programme quantique complet est requis pour chaque exécution de QPU.
· QPU fonctionne en quelques microsecondes.
Afin de le rendre pratique et de surmonter les obstacles, l'équipe TFQ a proposé des concepts architecturaux incontournables dans le cadre de la programmation. Les normes architecturales sont les suivantes:
1. Différenciabilité: Il est nécessaire de prendre en charge la propagation inverse différentielle et hybride des circuits quantiques.
2. Traitement par lots des circuits: les données quantiques sont téléchargées en tant que circuit quantique et plusieurs circuits différents sont entraînés en parallèle.
3. Le backend d'exécution est agnostique: vous pouvez passer du simulateur à l'appareil réel en quelques étapes.
4. Minimalisme - le pont entre Cirq et TF: pas besoin pour les utilisateurs de réapprendre à interagir avec des ordinateurs quantiques pour résoudre des problèmes d'apprentissage automatique.
Source: unsplash
Pas à pas
Pipeline TFQ de modèle discriminant mixte
étape 1:
Préparez un ensemble de données quantiques: les données quantiques sont chargées comme un tenseur, défini comme un circuit quantique écrit en Cirq. Les tenseurs sont exécutés par TensorFlow sur des ordinateurs quantiques pour générer des ensembles de données quantiques.
L'ensemble de données quantiques est un objet cirq.Circuit non paramétrique qui est appliqué à l'infographie et utilise tfq.convert_to_tensor.
Étape 2:
Évaluer le modèle de réseau neuronal quantique: dans cette étape, les chercheurs peuvent utiliser Cirq pour prototyper un réseau neuronal quantique, puis l'intégrer dans le graphique de calcul TensorFlow.
La construction du modèle quantique utilise cirq.Circuit pour contenir les objets symboles SymPy et peut être superposée et attachée à des sources de données quantiques à l'aide de tfq.
Étape 3:
Échantillon ou moyenne: cette étape utilise plusieurs séries d'étapes (1) et (2) pour effectuer la moyenne. Échantillons ou moyennage en envoyant des données quantiques et des modèles quantiques à la couche tfq.Sample ou tfq.Expectation.
Étape 4:
Évaluer le modèle de réseau neuronal classique: cette étape utilise le réseau neuronal profond classique pour extraire la corrélation entre les métriques extraites à l'étape précédente. Étant donné que TFQ est entièrement compatible avec TensorFlow, les modèles quantiques peuvent directement contacter tf.keras.layers.Layer, tels que tf.keras.layers.Dense. Et d'autres objets.
Source: unsplash
Étape 5:
Fonction de coût d'évaluation: similaire au modèle d'apprentissage automatique traditionnel, TFQ évalue la fonction de coût à travers cette étape. Si les données quantiques sont étiquetées, la fonction de coût d'évaluation peut être basée sur la précision de la tâche de classification effectuée par le modèle. Si la tâche n'est pas supervisée, elle est basée sur d'autres critères.
Les modèles construits dans les étapes (1) à (4) sont regroupés dans tf.keras.Model, permettant aux utilisateurs d'accéder à toutes les pertes tf.keras.losses dans le module.
Étape 6:
Après avoir évalué le gradient et mis à jour les paramètres, après avoir évalué la fonction de coût, pour réduire les coûts, les paramètres libres dans le pipeline doivent être mis à jour dans la direction attendue.
Pour prendre en charge la descente de gradient, la dérivée des opérations quantiques est divulguée au mécanisme de rétropropagation TensorFlow. Grâce à tfq.differentiators.Differentiatorinterface, une rétropropagation quantique-classique mixte permet d'optimiser les paramètres des modèles quantiques et classiques pour les données quantiques.
Source: unsplash
Démo de codage
#Importation de dépendances ! pip install --upgrade cirq == 0.7.0 ! pip install --upgrade tensorflow == 2.1.0 ! pip install qutip ! pip installe tensorflow-quantum importer cirq import numpy as np importer une astuce importer au hasard importer sympy importer tensorflow en tant que tf importer tensorflow_quantum en tant que tfq #Quantum Dataset def generate_dataset (qubit, theta_a, theta_b, num_samples): "" "Génère un ensemble de données de points sur" qubit "près des angles à deux axes; étiquettes pour les deux clusters, utilisez un codage à chaud. "" " q_data = bloch = {"a" :, "b":} labels = blob_size = abs (theta_a-theta_b) / 5 pour _ inrange (num_samples): coin = random.random () spread_x = np.random.uniform (-blob_size, blob_size) spread_y = np.random.uniform (-blob_size, blob_size) si pièce < 0,5: label = angle = theta_a + spread_y source = "a" autre: label = angle = theta_b + spread_y source = "b" labels.append (étiquette) q_data.append (cirq.Circuit (cirq.ry (-angle) (qubit), cirq.rx (-spread_x) (qubit))) bloch.append (np.cos (angle)) bloch.append (np.sin (angle) * np.sin (spread_x)) bloch.append (np.sin (angle) * np.cos (spread_x)) returntfq.convert_to_tensor (q_data), np.array (labels), bloch #Générer l'ensemble de données qubit = cirq.GridQubit (0, 0) theta_a = 1 theta_b = 4 num_samples = 200 q_data, labels, bloch_p = generate_dataset (qubit, theta_a, theta_b, num_samples #Modèle #Nous utiliserons une rotation paramétrée autour de l'axe Y suivie d'une mesure de l'axe Z comme partie quantique de notre modèle. Pour la partie classique, nous utiliserons un SoftMax à deux unités qui devrait apprendre à distinguer les statistiques de mesure des deux sources de données. # Construire la couche du modèle quantique thêta = sympy.Symbol ('thêta') q_model = cirq.Circuit (cirq.ry (thêta) (qubit)) q_data_input = tf.keras.Input ( forme = (), dtype = tf.dtypes.string) attente = tfq.layers.PQC (q_model, cirq.Z (qubit)) expectation_output = attente (q_data_input) # Attachez le classificateur SoftMax classique classifier = tf.keras.layers.Dense (2, activation = tf.keras.activations.softmax) classifier_output = classifier (expectation_output) modèle = tf.keras.Model (entrées = q_data_input, sorties = classifier_output) # Compilation standard pour la classification model.compile (optimizer = tf.keras.optimizers.Adam (learning_rate = 0.1), loss = tf.keras.losses.CategoricalCrossentropy ()) tf.keras.utils.plot_model (modèle, show_shapes = True, dpi = 70) #Entraînement history = model.fit (x = q_data, y = labels, epochs = 50, verbose = 0) test_data, _, _ = generate_dataset (qubit, theta_a, theta_b, 1) p = model.predict (test_data) print (f "prob (a) = {p: .4f}, prob (b) = {p: .4f}")
Source: unsplash
Nous avons découvert le réseau neuronal quantique en quelques étapes très simples et l'avons même exécuté avec TFQ, ce qui est vraiment surprenant. TFQ est appelé à être un énorme bond en avant dans l'histoire de l'apprentissage automatique.
laissez un commentaire
Partageons ensemble les produits de base de l'apprentissage et du développement de l'IA
Si réimprimé, veuillez laisser un message en arrière-plan et suivre les spécifications de réimpression
