{ "cells": [ { "cell_type": "markdown", "id": "a0f5b3c9-754e-47d4-8dc7-5af247070187", "metadata": {}, "source": [ "---\n", "title: \"Créer et transcompiler par rapport à des backends personnalisés\"\n", "description: \"Apprenez à créer vos propres backends personnalisés et à transcompiler des circuits par rapport à ceux-ci\"\n", "---\n", "\n", "{/* cspell:ignore multichip interchip Lasciate ogne speranza voi ch'intrate */}\n", "\n" ] }, { "cell_type": "markdown", "id": "9429c31d-84b1-4547-9227-0b2fcf8a0193", "metadata": {}, "source": [ "\n", "\n", "# Créer et transcompiler par rapport à des backends personnalisés\n", "\n" ] }, { "cell_type": "markdown", "id": "27349ef1-5e25-4762-8a6f-8b4c265763c9", "metadata": { "tags": [ "version-info" ] }, "source": [ "{/*\n", " DO NOT EDIT THIS CELL!!!\n", " This cell's content is generated automatically by a script. Anything you add\n", " here will be removed next time the notebook is run. To add new content, create\n", " a new cell before or after this one.\n", " */}\n", "\n", "\n", " \n", " Le code de cette page a été développé en tenant compte des exigences suivantes.\n", " Nous recommandons d'utiliser ces versions ou des versions plus récentes.\n", "\n", " ```\n", " qiskit[all]~=2.5.1\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "678c28a1-d1ee-4179-8c7a-be5698e045bb", "metadata": {}, "source": [ "{/* cspell:ignore LOCC */}\n", "\n", "L'une des caractéristiques les plus puissantes de Qiskit est sa capacité à prendre en charge des configurations d'appareils uniques. Qiskit est conçu pour être indépendant du fournisseur du matériel quantique que vous utilisez, et les fournisseurs peuvent configurer l'objet `BackendV2` en fonction de leurs propres propriétés. Cette rubrique montre comment configurer son propre backend et transposer les circuits quantiques.\n", "\n", "Vous pouvez créer des objets `BackendV2` uniques avec différentes géométries ou portes de base et transposer vos circuits en tenant compte de ces configurations. L'exemple ci-dessous couvre un backend avec un réseau de qubits disjoints, dont les portes de base sont différentes le long des bords par rapport à l'intérieur de la masse.\n", "\n" ] }, { "cell_type": "markdown", "id": "77d43aaf-5f92-412d-b49a-30be82268d21", "metadata": {}, "source": [ "\n", "\n", "## Comprendre les interfaces Provider, BackendV2 et Target\n", "\n", "Avant de commencer, il est utile de comprendre l'utilisation et l'objectif de l'élément [`Provider`](../api/qiskit/providers), [`BackendV2`](../api/qiskit/qiskit.providers.BackendV2), et [`Target`](../api/qiskit/qiskit.transpiler.Target) et des objets.\n", "\n", "* Si vous avez un dispositif quantique ou un simulateur que vous voulez intégrer dans le SDK Qiskit, vous devez écrire votre propre classe `Provider` . Cette classe n'a qu'un seul but : récupérer les objets backend que vous lui fournissez. C'est là que sont traitées toutes les tâches d'identification et/ou d'authentification requises. Une fois instancié, l'objet fournisseur fournira une liste de backends ainsi que la possibilité d'acquérir/instaurer des backends.\n", "\n", "* Ensuite, les classes backend fournissent l'interface entre le SDK Qiskit et le matériel ou le simulateur qui exécutera les circuits. Ils comprennent toutes les informations nécessaires pour décrire un backend au transpileur afin qu'il puisse optimiser n'importe quel circuit en fonction de ses contraintes. Un site `BackendV2` est constitué de quatre parties principales :\n", " * A [`Target`](../api/qiskit/qiskit.transpiler.Target) qui contient une description des contraintes du backend et fournit un modèle du backend pour le transpondeur\n", " * Une propriété `max_circuits` qui définit une limite sur le nombre de circuits qu'un backend peut exécuter en un seul travail\n", " * Une méthode `run()` qui accepte les soumissions de travaux\n", " * Un ensemble de `_default_options` pour définir les options configurables par l'utilisateur et leurs valeurs par défaut\n", "\n" ] }, { "cell_type": "markdown", "id": "0ad9dc45-97e9-4e47-b7c0-2fa536d4e624", "metadata": {}, "source": [ "\n", "\n", "## Créer un fichier personnalisé BackendV2\n", "\n", "L'objet `BackendV2` est une classe abstraite utilisée pour tous les objets backend créés par un fournisseur (soit dans `qiskit.providers` , soit dans une autre bibliothèque telle que [`qiskit_ibm_runtime.IBMBackend`](../api/qiskit-ibm-runtime/ibm-backend)). Comme indiqué plus haut, ces objets contiennent plusieurs attributs, dont un attribut [`Target`](/docs/api/qiskit/qiskit.transpiler.Target). Le site `Target` contient des informations qui précisent les attributs du backend - tels que la liste des attributs du backend [`Coupling Map`](/docs/api/qiskit/qiskit.transpiler.CouplingMap), la liste des [`Instructions`](/docs/api/qiskit/qiskit.circuit.Instruction)et d'autres - au transpileur. Outre le site `Target`, il est possible de définir des détails au niveau de l'impulsion, tels que les paramètres [`DriveChannel`](/docs/api/qiskit/1.4/qiskit.pulse.channels.DriveChannel) ou [`ControlChannel`](/docs/api/qiskit/1.4/qiskit.pulse.channels.ControlChannel).\n", "\n", "L'exemple suivant démontre cette personnalisation en créant un backend multi-puces simulé, où chaque puce possède une connectivité heavy-hex. L'exemple spécifie que l'ensemble de portes à deux qubits du backend doit être [`CZGates`](../api/qiskit/qiskit.circuit.library.CZGate) dans chaque puce et [`CXGates`](../api/qiskit/qiskit.circuit.library.ECRGate) entre les puces. Tout d'abord, créez votre propre site `BackendV2` et personnalisez son site `Target` avec des portes à un ou deux qubits selon les contraintes décrites précédemment.\n", "\n", "\n", " Le tracé d'une carte de couplage nécessite l'installation de la bibliothèque [`graphviz`](https://graphviz.org/) soit installée.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "b346f50b-b127-4074-99fc-7c53e3fbc022", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import rustworkx as rx\n", "\n", "from qiskit.providers import BackendV2, Options\n", "from qiskit.transpiler import Target, InstructionProperties\n", "from qiskit.circuit.library import XGate, SXGate, RZGate, CZGate, ECRGate\n", "from qiskit.circuit import Measure, Delay, Parameter, Reset\n", "from qiskit import QuantumCircuit, transpile\n", "from qiskit.visualization import plot_gate_map\n", "\n", "\n", "class FakeLOCCBackend(BackendV2):\n", " \"\"\"Fake multi chip backend.\"\"\"\n", "\n", " def __init__(self, distance=3, number_of_chips=3):\n", " \"\"\"Instantiate a new fake multi chip backend.\n", "\n", " Args:\n", " distance (int): The heavy hex code distance to use for each chips'\n", " coupling map. This number **must** be odd. The distance relates\n", " to the number of qubits by:\n", " :math:`n = \\\\frac{5d^2 - 2d - 1}{2}` where :math:`n` is the\n", " number of qubits and :math:`d` is the ``distance``\n", " number_of_chips (int): The number of chips to have in the multichip backend\n", " each chip will be a heavy hex graph of ``distance`` code distance.\n", " \"\"\"\n", " super().__init__(name=\"Fake LOCC backend\")\n", " # Create a heavy-hex graph using the\n", " # rustworkx library, then instantiate a new target\n", " self._graph = rx.generators.directed_heavy_hex_graph(\n", " distance, bidirectional=False\n", " )\n", " num_qubits = len(self._graph) * number_of_chips\n", " self._target = Target(\n", " \"Fake multi-chip backend\", num_qubits=num_qubits\n", " )\n", "\n", " # Generate instruction properties for single qubit gates and a measurement, delay,\n", " # and reset operation to every qubit in the backend.\n", " rng = np.random.default_rng(seed=12345678942)\n", " rz_props = {}\n", " x_props = {}\n", " sx_props = {}\n", " measure_props = {}\n", " delay_props = {}\n", "\n", " # Add 1q gates. Globally use virtual rz, x, sx, and measure\n", " for i in range(num_qubits):\n", " qarg = (i,)\n", " rz_props[qarg] = InstructionProperties(error=0.0, duration=0.0)\n", " x_props[qarg] = InstructionProperties(\n", " error=rng.uniform(1e-6, 1e-4),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " sx_props[qarg] = InstructionProperties(\n", " error=rng.uniform(1e-6, 1e-4),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " measure_props[qarg] = InstructionProperties(\n", " error=rng.uniform(1e-3, 1e-1),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " delay_props[qarg] = None\n", " self._target.add_instruction(XGate(), x_props)\n", " self._target.add_instruction(SXGate(), sx_props)\n", " self._target.add_instruction(RZGate(Parameter(\"theta\")), rz_props)\n", " self._target.add_instruction(Measure(), measure_props)\n", " self._target.add_instruction(Reset(), measure_props)\n", "\n", " self._target.add_instruction(Delay(Parameter(\"t\")), delay_props)\n", " # Add chip local 2q gate which is CZ\n", " cz_props = {}\n", " for i in range(number_of_chips):\n", " for root_edge in self._graph.edge_list():\n", " offset = i * len(self._graph)\n", " edge = (root_edge[0] + offset, root_edge[1] + offset)\n", " cz_props[edge] = InstructionProperties(\n", " error=rng.uniform(7e-4, 5e-3),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " self._target.add_instruction(CZGate(), cz_props)\n", "\n", " cx_props = {}\n", " # Add interchip 2q gates which are ecr (effectively CX)\n", " # First determine which nodes to connect\n", " node_indices = self._graph.node_indices()\n", " edge_list = self._graph.edge_list()\n", " inter_chip_nodes = {}\n", " for node in node_indices:\n", " count = 0\n", " for edge in edge_list:\n", " if node == edge[0]:\n", " count += 1\n", " if count == 1:\n", " inter_chip_nodes[node] = count\n", " # Create inter-chip ecr props\n", " cx_props = {}\n", " inter_chip_edges = list(inter_chip_nodes.keys())\n", " for i in range(1, number_of_chips):\n", " offset = i * len(self._graph)\n", " edge = (\n", " inter_chip_edges[1] + (len(self._graph) * (i - 1)),\n", " inter_chip_edges[0] + offset,\n", " )\n", " cx_props[edge] = InstructionProperties(\n", " error=rng.uniform(7e-4, 5e-3),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", "\n", " self._target.add_instruction(ECRGate(), cx_props)\n", "\n", " @property\n", " def target(self):\n", " return self._target\n", "\n", " @property\n", " def max_circuits(self):\n", " return None\n", "\n", " @property\n", " def graph(self):\n", " return self._graph\n", "\n", " @classmethod\n", " def _default_options(cls):\n", " return Options(shots=1024)\n", "\n", " def run(self, circuit, **kwargs):\n", " raise NotImplementedError(\n", " \"This backend does not contain a run method\"\n", " )" ] }, { "cell_type": "markdown", "id": "64a418fa-7a7e-4a12-b9c9-ff7377bffed4", "metadata": {}, "source": [ "\n", "\n", "### Visualiser les backends\n", "\n", "Vous pouvez visualiser le graphe de connectivité de cette nouvelle classe avec la méthode [`plot_gate_map()`](../api/qiskit/qiskit.visualization.plot_gate_map) du module `qiskit.visualization` . Cette méthode, ainsi que les méthodes [`plot_coupling_map()`](../api/qiskit/qiskit.visualization.plot_coupling_map) et [`plot_circuit_layout()`](../api/qiskit/qiskit.visualization.plot_circuit_layout)sont des outils utiles pour visualiser la disposition des qubits d'un backend, ainsi que la façon dont un circuit est disposé sur les qubits d'un backend. Cet exemple crée un backend contenant trois petites puces heavy-hex. Il spécifie un ensemble de coordonnées pour disposer les qubits, ainsi qu'un ensemble de couleurs personnalisées pour les différentes portes à deux qubits.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "fcc3056a-4e89-4b35-a0d5-e5c676459cc2", "metadata": {}, "outputs": [], "source": [ "backend = FakeLOCCBackend(3, 3)\n", "\n", "\n", "target = backend.target\n", "coupling_map_backend = target.build_coupling_map()\n", "\n", "\n", "coordinates = [\n", " (3, 1),\n", " (3, -1),\n", " (2, -2),\n", " (1, 1),\n", " (0, 0),\n", " (-1, -1),\n", " (-2, 2),\n", " (-3, 1),\n", " (-3, -1),\n", " (2, 1),\n", " (1, -1),\n", " (-1, 1),\n", " (-2, -1),\n", " (3, 0),\n", " (2, -1),\n", " (0, 1),\n", " (0, -1),\n", " (-2, 1),\n", " (-3, 0),\n", "]\n", "\n", "single_qubit_coordinates = []\n", "total_qubit_coordinates = []\n", "\n", "\n", "for coordinate in coordinates:\n", " total_qubit_coordinates.append(coordinate)\n", "\n", "for coordinate in coordinates:\n", " total_qubit_coordinates.append(\n", " (-1 * coordinate[0] + 1, coordinate[1] + 4)\n", " )\n", "\n", "for coordinate in coordinates:\n", " total_qubit_coordinates.append((coordinate[0], coordinate[1] + 8))\n", "\n", "\n", "line_colors = [\"#adaaab\" for edge in coupling_map_backend.get_edges()]\n", "ecr_edges = []\n", "\n", "# Get tuples for the edges which have an ecr instruction attached\n", "for instruction in target.instructions:\n", " if instruction[0].name == \"ecr\":\n", " ecr_edges.append(instruction[1])\n", "\n", "for i, edge in enumerate(coupling_map_backend.get_edges()):\n", " if edge in ecr_edges:\n", " line_colors[i] = \"#000000\"" ] }, { "cell_type": "code", "execution_count": 4, "id": "6dc04d04-7afb-46f2-8ee6-ac961e4583f5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Fake LOCC backend\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(backend.name)\n", "plot_gate_map(\n", " backend,\n", " plot_directed=True,\n", " qubit_coordinates=total_qubit_coordinates,\n", " line_color=line_colors,\n", ")" ] }, { "cell_type": "markdown", "id": "d61da191-caa0-4175-a5f4-741b60905cdc", "metadata": {}, "source": [ "Chaque qubit est étiqueté et les flèches colorées représentent les portes à deux qubits. Les flèches grises représentent les portes CZ et les flèches noires les portes CX inter-puces (elles relient les qubits $6 \\rightarrow 21$ et $25 \\rightarrow 40$ ). La direction de la flèche indique la direction par défaut dans laquelle ces portes sont exécutées; elles spécifient quels qubits sont contrôlés/cibles par défaut pour chaque canal à deux qubits.\n", "\n" ] }, { "cell_type": "markdown", "id": "59dc66df-5fb8-4844-922c-714fa86f08d5", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Transpiler contre des backends personnalisés\n", "\n", "Maintenant qu'un backend personnalisé avec son propre et unique [`Target`](../api/qiskit/qiskit.transpiler.Target) a été défini, il est facile de transposer les circuits quantiques dans ce backend, puisque toutes les contraintes pertinentes (portes de base, connectivité des qubits, etc.) nécessaires aux passes du transpileur sont contenues dans cet attribut. L'exemple suivant construit un circuit qui crée un état GHZ important et le transpose sur le backend construit ci-dessus.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "cf2b1e0f-e6a1-4274-af7b-e5d4d3df6add", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Pre-Transpilation: \n", "CX gates: 49\n", "H gates: 50\n", "\n", " ############################## \n", "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Post-Transpilation: \n", "CZ gates: 207\n", "ECR gates: 8\n", "SX gates: 379\n", "RZ gates: 211\n" ] } ], "source": [ "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", "num_qubits = 50\n", "ghz = QuantumCircuit(num_qubits)\n", "ghz.h(range(num_qubits))\n", "ghz.cx(0, range(1, num_qubits))\n", "op_counts = ghz.count_ops()\n", "\n", "print(\"Pre-Transpilation: \")\n", "print(f\"CX gates: {op_counts['cx']}\")\n", "print(f\"H gates: {op_counts['h']}\")\n", "print(\"\\n\", 30 * \"#\", \"\\n\")\n", "\n", "pm = generate_preset_pass_manager(optimization_level=3, backend=backend)\n", "transpiled_ghz = pm.run(ghz)\n", "op_counts = transpiled_ghz.count_ops()\n", "\n", "print(\"Post-Transpilation: \")\n", "print(f\"CZ gates: {op_counts['cz']}\")\n", "print(f\"ECR gates: {op_counts['ecr']}\")\n", "print(f\"SX gates: {op_counts['sx']}\")\n", "print(f\"RZ gates: {op_counts['rz']}\")" ] }, { "cell_type": "markdown", "id": "58625e26-e078-4ee6-8549-362762450a3b", "metadata": {}, "source": [ "Le circuit transpilé contient désormais un mélange de portes `CZ` `ECR` et, que nous avons spécifiées comme portes de base dans le du backend `Target`. Il y a également beaucoup plus de portes qu'au départ, car il faut insérer des instructions SWAP après avoir choisi une disposition. Ci-dessous, l'outil [`plot_circuit_layout()`](/docs/api/qiskit/qiskit.visualization.plot_circuit_layout) de visualisation est utilisé pour spécifier quels qubits et canaux à deux qubits ont été utilisés dans ce circuit.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "b51657ed-bb37-4e1a-9dea-8189b4229d24", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.visualization import plot_circuit_layout\n", "\n", "plot_circuit_layout(\n", " transpiled_ghz, backend, qubit_coordinates=total_qubit_coordinates\n", ")" ] }, { "cell_type": "markdown", "id": "ec002958-7eda-4329-aabb-cdf1b4c61403", "metadata": {}, "source": [ "\n", "\n", "## Créer des backends uniques\n", "\n", "Le paquet [rustworkx](https://www.rustworkx.org/) contient une large bibliothèque de graphiques différents et permet de créer des graphiques personnalisés. Le code visuellement intéressant ci-dessous crée un backend inspiré du code torique. Vous pouvez ensuite visualiser le backend à l'aide des fonctions de la section [Visualiser les backends](#visualize-backends).\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "82b8fa47-b37f-4136-9e3a-ffa5bc72fdf5", "metadata": {}, "outputs": [], "source": [ "class FakeTorusBackend(BackendV2):\n", " \"\"\"Fake multi chip backend.\"\"\"\n", "\n", " def __init__(self):\n", " \"\"\"Instantiate a new backend that is inspired by a toric code\"\"\"\n", " super().__init__(name=\"Fake LOCC backend\")\n", " graph = rx.generators.directed_grid_graph(20, 20)\n", " for column in range(20):\n", " graph.add_edge(column, 19 * 20 + column, None)\n", " for row in range(20):\n", " graph.add_edge(row * 20, row * 20 + 19, None)\n", " num_qubits = len(graph)\n", " rng = np.random.default_rng(seed=12345678942)\n", " rz_props = {}\n", " x_props = {}\n", " sx_props = {}\n", " measure_props = {}\n", " delay_props = {}\n", " self._target = Target(\"Fake Kookaburra\", num_qubits=num_qubits)\n", " # Add 1q gates. Globally use virtual rz, x, sx, and measure\n", " for i in range(num_qubits):\n", " qarg = (i,)\n", " rz_props[qarg] = InstructionProperties(error=0.0, duration=0.0)\n", " x_props[qarg] = InstructionProperties(\n", " error=rng.uniform(1e-6, 1e-4),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " sx_props[qarg] = InstructionProperties(\n", " error=rng.uniform(1e-6, 1e-4),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " measure_props[qarg] = InstructionProperties(\n", " error=rng.uniform(1e-3, 1e-1),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " delay_props[qarg] = None\n", " self._target.add_instruction(XGate(), x_props)\n", " self._target.add_instruction(SXGate(), sx_props)\n", " self._target.add_instruction(RZGate(Parameter(\"theta\")), rz_props)\n", " self._target.add_instruction(Measure(), measure_props)\n", " self._target.add_instruction(Reset(), measure_props)\n", " self._target.add_instruction(Delay(Parameter(\"t\")), delay_props)\n", " cz_props = {}\n", " for edge in graph.edge_list():\n", " cz_props[edge] = InstructionProperties(\n", " error=rng.uniform(7e-4, 5e-3),\n", " duration=rng.uniform(1e-8, 9e-7),\n", " )\n", " self._target.add_instruction(CZGate(), cz_props)\n", "\n", " @property\n", " def target(self):\n", " return self._target\n", "\n", " @property\n", " def max_circuits(self):\n", " return None\n", "\n", " @classmethod\n", " def _default_options(cls):\n", " return Options(shots=1024)\n", "\n", " def run(self, circuit, **kwargs):\n", " raise NotImplementedError(\"Lasciate ogne speranza, voi ch'intrate\")" ] }, { "cell_type": "code", "execution_count": 8, "id": "1d40864a-7695-438b-95bf-7724c34d92b4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "backend = FakeTorusBackend()\n", "# We set `figsize` to a smaller size to make the documentation website faster\n", "# to load. Normally, you do not need to set the argument.\n", "plot_gate_map(backend, figsize=(4, 4))" ] }, { "cell_type": "code", "execution_count": 9, "id": "341a0256-4a76-4d84-b598-5fc4d9fbef19", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CZ gates: 580\n", "X gates: 129\n", "SX gates: 936\n", "RZ gates: 840\n" ] } ], "source": [ "num_qubits = int(backend.num_qubits / 2)\n", "full_device_bv = QuantumCircuit(num_qubits, num_qubits - 1)\n", "full_device_bv.x(num_qubits - 1)\n", "full_device_bv.h(range(num_qubits))\n", "full_device_bv.cx(range(num_qubits - 1), num_qubits - 1)\n", "full_device_bv.h(range(num_qubits))\n", "full_device_bv.measure(range(num_qubits - 1), range(num_qubits - 1))\n", "tqc = transpile(full_device_bv, backend, optimization_level=3)\n", "op_counts = tqc.count_ops()\n", "print(f\"CZ gates: {op_counts['cz']}\")\n", "print(f\"X gates: {op_counts['x']}\")\n", "print(f\"SX gates: {op_counts['sx']}\")\n", "print(f\"RZ gates: {op_counts['rz']}\")" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3" } }, "nbformat": 4, "nbformat_minor": 2 }