docs/tutorials/fetch_device_params.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "immune-signature",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Author: Thaddeus Pellegrini (thaddeus.pellegrini@ibm.com)\n",
    "# Created: Wed. March 1 2023\n",
    "# Modified by Haoran Liao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "applicable-disclosure",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, timedelta\n",
    "from qiskit import IBMQ\n",
    "from collections import defaultdict\n",
    "import json\n",
    "from tqdm.notebook import tqdm_notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "uniform-circumstances",
   "metadata": {},
   "outputs": [],
   "source": [
    "IBMQ.load_account()\n",
    "provider = IBMQ.get_provider(hub=\"ibm-q-internal\", group='deployed')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "compressed-speed",
   "metadata": {},
   "outputs": [],
   "source": [
    "backends =  ['ibmq_montreal']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "encouraging-birmingham",
   "metadata": {},
   "outputs": [],
   "source": [
    "interval_hour = 3 # interval in hours, sampling frequency\n",
    "intervals = 120 # intervals*interval_hour = sampling time\n",
    "ref_point = datetime.now() # change this to some datetime object if you want to grab data from different timeframe\n",
    "\n",
    "times = []\n",
    "for i in range(intervals):\n",
    "    past_time = ref_point - timedelta(hours=i * interval_hour)\n",
    "    times.append(past_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "crude-mistress",
   "metadata": {},
   "source": [
    "Format of datastructure:\n",
    "    \n",
    "historical_data.json:\n",
    "\n",
    "{ device_1: \n",
    "    {times: [list of strings, times at which data was sampled],\n",
    "     t1: {qubit_0: [list of t1 times, index corresponds to 'times'], qubit_1: [], ..., qubit_n: []},\n",
    "     t2: {qubit_0: [list of t2 times, index corresponds to 'times'], qubit_1: [], ..., qubit_n: []},\n",
    "     readout_err: {qubit_0: [list of readout errors, index corr. to 'times'], qubit_1: [], ..., qubit_n: []}\n",
    "     cnots: {edge_0_1: [list of cnot errors, index corr. to 'times'], ... edge_n_m: [...]}\n",
    "     },\n",
    "    \n",
    "  device_2: {...},\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "  device_n: {...}\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "solid-island",
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "data = {be: {} for be in backends}\n",
    "\n",
    "for be in backends:\n",
    "    print(be)\n",
    "    backend = provider.get_backend(be)\n",
    "    qubits = range(len(backend.properties().qubits))\n",
    "    t1 = defaultdict(list)\n",
    "    t2 = defaultdict(list)\n",
    "    readout_err = defaultdict(list)\n",
    "    cnot_err = defaultdict(list)\n",
    "    sx_err = defaultdict(list)\n",
    "    x_err = defaultdict(list)\n",
    "    \n",
    "    for qubit in qubits:\n",
    "        t1s = []\n",
    "        t2s = []\n",
    "        readout_errs = []\n",
    "        sx_errs = []\n",
    "        x_errs = []\n",
    "\n",
    "        for time in tqdm_notebook(times[::-1], leave=True):\n",
    "            try:\n",
    "                prop = backend.properties(datetime=time)\n",
    "                t1s.append(prop.t1(qubit=qubit))\n",
    "            except:\n",
    "                t1s.append(-1)\n",
    "\n",
    "            try: t2s.append(prop.t2(qubit=qubit))\n",
    "            except: t2s.append(-1)\n",
    "\n",
    "            try: readout_errs.append(prop.readout_error(qubit=qubit))\n",
    "            except: readout_errs.append(-1)\n",
    "\n",
    "            try: sx_errs.append(prop.gate_error(gate='sx', qubits=qubit))\n",
    "            except: sx_errs.append(-1)\n",
    "\n",
    "            try: x_errs.append(prop.gate_error(gate='x', qubits=qubit))\n",
    "            except: x_errs.append(-1)\n",
    "            \n",
    "        t1[qubit] = t1s\n",
    "        t2[qubit] = t2s\n",
    "        readout_err[qubit] = readout_errs\n",
    "        sx_err[qubit] = sx_errs\n",
    "        x_err[qubit] = x_errs\n",
    "    \n",
    "    try:\n",
    "        edges = backend.configuration().coupling_map # For BackendV1 (ibmq_device)\n",
    "    except:\n",
    "        edges = backend.coupling_map # For BackendV2 (ibm_device)\n",
    "\n",
    "    print('Getting CX errors...')\n",
    "    for edge in edges:\n",
    "        qubit_1 = edge[0]\n",
    "        qubit_2 = edge[1]\n",
    "        \n",
    "        cnots = []\n",
    "        for time in tqdm_notebook(times[::-1], leave=True):\n",
    "            print(time.strftime(\"%d-%m-%YT%H:%M:%S%Z\"))\n",
    "            try:\n",
    "                prop = backend.properties(datetime=time)\n",
    "                cnots.append(prop.gate_error(gate='cx', qubits=(qubit_1, qubit_2)))\n",
    "            except:\n",
    "                cnots.append(-1)\n",
    "            \n",
    "        e = str(qubit_1)+\"_\"+str(qubit_2)                \n",
    "        cnot_err[e] = cnots\n",
    "        \n",
    "    data[backend.properties().backend_name]['times']=[time.strftime(\"%d-%m-%YT%H:%M:%S%Z\") for time in times[::-1]]\n",
    "    data[backend.properties().backend_name]['t1']=t1\n",
    "    data[backend.properties().backend_name]['t2']=t2\n",
    "    data[backend.properties().backend_name]['readout_err']=readout_err\n",
    "    data[backend.properties().backend_name]['cnot_err']=cnot_err\n",
    "    data[backend.properties().backend_name]['sx_err']=sx_err\n",
    "    data[backend.properties().backend_name]['x_err']=x_err"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "automatic-albany",
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "with open(\"./device_params/ibmq_montreal_params.json\", \"w\") as outfile:\n",
    "    json.dump(data, outfile)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "minor-denmark",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ordered-cleaning",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "harmful-funds",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"./ibmq_lima_params.json\", \"r\") as file:\n",
    "    d = json.load(file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "d['ibmq_lima']['times']"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}