learn_and_fuse.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyterrier as pt  # type: ignore\n",
    "import os\n",
    "import yaml\n",
    "from tira.third_party_integrations import persist_and_normalize_run, ensure_pyterrier_is_loaded\n",
    "import pandas as pd\n",
    "from trectools import TrecRun, TrecQrel, TrecEval\n",
    "\n",
    "from trectools import TrecQrel, procedures\n",
    "\n",
    "ensure_pyterrier_is_loaded()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_run = pd.DataFrame([\n",
    "    {\"system\": \"1\", \"query\": \"q06223196\", \"q0\": \"Q0\", \"docid\": \"doc062200204465\", \"rank\": 1, \"score\": 0}, \n",
    "    {\"system\": \"1\", \"query\": \"q06223196\", \"q0\": \"Q0\", \"docid\": \"doc062200112743\", \"rank\": 2, \"score\": -1},\n",
    "    \n",
    "    {\"system\": \"1\", \"query\": \"q062219244\", \"q0\": \"Q0\", \"docid\": \"doc062200108085\", \"rank\": 1, \"score\": 1},\n",
    "    {\"system\": \"1\", \"query\": \"q062219244\", \"q0\": \"Q0\", \"docid\": \"doc062200106015\", \"rank\": 2, \"score\": -1},\n",
    "\n",
    "\n",
    "    {\"system\": \"2\", \"query\": \"q06223196\", \"q0\": \"Q0\", \"docid\": \"doc062200112743\", \"rank\": 1, \"score\": 0}, \n",
    "    {\"system\": \"2\", \"query\": \"q06223196\", \"q0\": \"Q0\", \"docid\": \"doc062200204465\", \"rank\": 2, \"score\": -1},\n",
    "    \n",
    "    {\"system\": \"2\", \"query\": \"q062219244\", \"q0\": \"Q0\", \"docid\": \"doc062200106015\", \"rank\": 1, \"score\": 1},\n",
    "    {\"system\": \"2\", \"query\": \"q062219244\", \"q0\": \"Q0\", \"docid\": \"doc062200108085\", \"rank\": 2, \"score\": -1},\n",
    "    ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_doc_translation():\n",
    "    ret = pd.read_csv(\"data/core_docs.tsv\", sep=\"\\t\")\n",
    "    return {i['docno_WT']: {'WT': i['docno_WT'], 'LT': i['docno_LT'], 'ST': i['docno_ST']} for _, i in ret.iterrows()}\n",
    "\n",
    "doc_translation = load_doc_translation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_query_translation(target_corpus):\n",
    "    ret = pd.read_csv(\"data/core_queries.tsv\", sep=\"\\t\")\n",
    "    return {i[f'qid_{target_corpus}']: i['qid_WT'] for _, i in ret.iterrows()}\n",
    "\n",
    "\n",
    "def sorted_training_data_for_query(qid):\n",
    "    ret_train = pd.read_csv(\"data/publish/French/Qrels/train.txt\", names=[\"qid\", \"Q0\", \"docno\", \"relevance\"], sep=\" \")\n",
    "    ret_test = pd.read_csv(\"data/longeval-relevance-judgements/heldout-test.txt\", names=[\"qid\", \"Q0\", \"docno\", \"relevance\"], sep=\" \")\n",
    "    \n",
    "    ret = pd.concat([ret_train, ret_test])\n",
    "    return ret[ret[\"qid\"].astype(str)==qid].sort_values(\"relevance\", ascending=False)\n",
    "\n",
    "\n",
    "def ground_truth_ranking_from_training_data(qid):\n",
    "    mapping = {\"q06\": \"WT\", \"q07\": \"ST\", \"q09\": \"LT\"}\n",
    "    target_corpus = mapping[qid[:3]]\n",
    "    query_mapping = load_query_translation(target_corpus)\n",
    "    \n",
    "    training_data = sorted_training_data_for_query(query_mapping[qid])\n",
    "\n",
    "    training_data[\"translated\"] = training_data[\"docno\"].apply(lambda i: doc_translation.get(i, {}).get(target_corpus, None))\n",
    "    training_data = training_data.dropna()\n",
    "    return pd.DataFrame([{'qid': qid, 'docno': i['translated'], 'score': i['relevance']} for _, i in training_data.iterrows()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ground_truth_ranking_from_training_data_transformer(df):\n",
    "    qids = df[\"qid\"].unique()\n",
    "    qid_to_query = {i['qid']: i['query'] for _, i in df.iterrows()}\n",
    "\n",
    "    ret = []\n",
    "    for qid in qids:\n",
    "        ranking = ground_truth_ranking_from_training_data(qid)\n",
    "\n",
    "        if len(ranking)> 0:\n",
    "            ranking[\"query\"] = ranking['qid'].apply(lambda i: qid_to_query[i])\n",
    "        ret.append(ranking)\n",
    "    return pd.concat(ret)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def qrels_for_query(qid):\n",
    "    ground_truth = ground_truth_ranking_from_training_data(qid)\n",
    "    ground_truth = ground_truth.rename(columns={\"qid\": \"query\", \"docno\": \"docid\", \"score\": \"rel\"})\n",
    "    ground_truth[\"q0\"] = \"q0\"\n",
    "    ret = TrecQrel()\n",
    "    ret.qrels_data = ground_truth\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_run_by_system(qid, system, all_runs):\n",
    "    run = all_runs[(all_runs[\"qid\"] == qid) & (all_runs[\"system\"]==system)].copy()\n",
    "    run = run.rename(columns = {\"query\": \"query_string\"})\n",
    "    run = run.rename(columns = {\"qid\": \"query\", \"docno\": \"docid\"})\n",
    "    ret = TrecRun()\n",
    "    ret.run_data = run\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_score_of_system_on_query(qid, all_runs, system, measure=\"NDCG_5\"):\n",
    "    try:\n",
    "        qrels = qrels_for_query(qid)\n",
    "        run = get_run_by_system(qid, system, all_runs)\n",
    "        \n",
    "        ret = TrecEval(run, qrels).get_ndcg(depth=10, removeUnjudged=True)\n",
    "    except:\n",
    "        print(qid)\n",
    "        return -1\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_best_system_per_query(qid, all_runs, measure=\"NDCG_5\"):\n",
    "    systems = all_runs[\"system\"].unique()\n",
    "    best_system = None\n",
    "    best_score = None\n",
    "\n",
    "    for system in systems:\n",
    "        score_of_system = calculate_score_of_system_on_query(qid, all_runs, system)\n",
    "        if best_system is None or best_score < score_of_system:\n",
    "            best_system = system\n",
    "            best_score = score_of_system\n",
    "    return best_system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_run(all_runs):\n",
    "    ret = []\n",
    "    for qid in all_runs[\"qid\"].unique():\n",
    "        best_system = select_best_system_per_query(qid, all_runs)\n",
    "        ret.append(all_runs[(all_runs[\"qid\"] == qid) & (all_runs[\"system\"]==best_system)].copy())\n",
    "\n",
    "    return pd.concat(ret)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create Runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_runs(system_name):\n",
    "    ret = []\n",
    "    for subcollection in [\"WT\", \"ST\", \"LT\"]:\n",
    "        ret.append(pt.io.read_results(f\"results/test/{system_name}.{subcollection}\"))\n",
    "    ret.append(pt.io.read_results(f\"results/train/{system_name}.WT\"))\n",
    "    return pt.Transformer.from_df(pd.concat(ret).sort_values([\"qid\", \"rank\"]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join(\".\", \"settings.yml\"), \"r\") as yamlfile:\n",
    "    config = yaml.load(yamlfile, Loader=yaml.FullLoader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "core_queries = pd.read_csv(\"data/core_queries.tsv\", sep=\"\\t\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17:32:12.119 [main] WARN org.terrier.structures.BaseCompressingMetaIndex - Structure meta reading data file directly from disk (SLOW) - try index.meta.data-source=fileinmem in the index properties file. 2.3 GiB of memory would be required.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "BR(BM25): 100%|██████████| 124/124 [02:40<00:00,  1.29s/q]\n",
      "BR(BM25): 100%|██████████| 122/122 [02:43<00:00,  1.34s/q]\n",
      "BR(BM25): 100%|██████████| 122/122 [02:44<00:00,  1.35s/q]\n",
      "BR(BM25): 100%|██████████| 124/124 [02:38<00:00,  1.28s/q]\n",
      "BR(BM25): 100%|██████████| 124/124 [02:47<00:00,  1.35s/q]\n",
      "BR(BM25): 100%|██████████| 124/124 [02:39<00:00,  1.28s/q]\n",
      "BR(BM25): 100%|██████████| 124/124 [02:48<00:00,  1.36s/q]\n",
      "BR(BM25): 100%|██████████| 124/124 [02:48<00:00,  1.36s/q]\n",
      "BR(BM25): 100%|██████████| 124/124 [02:54<00:00,  1.41s/q]\n",
      "BR(BM25): 100%|██████████| 124/124 [02:51<00:00,  1.38s/q]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "q09225884\n",
      "q09225884\n",
      "q09225884\n",
      "q09225884\n",
      "q09225884\n",
      "q09225884\n",
      "q09225884\n",
      "q09225884\n",
      "q09225884\n",
      "q09225884\n",
      "q092232018\n",
      "q092232018\n",
      "q092232018\n",
      "q092232018\n",
      "q092232018\n",
      "q092232018\n",
      "q092232018\n",
      "q092232018\n",
      "q092232018\n",
      "q092232018\n",
      "18:04:08.182 [main] WARN org.terrier.structures.BaseCompressingMetaIndex - Structure meta reading data file directly from disk (SLOW) - try index.meta.data-source=fileinmem in the index properties file. 3.4 GiB of memory would be required.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "BR(BM25): 100%|██████████| 124/124 [02:18<00:00,  1.12s/q]\n",
      "BR(BM25): 100%|██████████| 122/122 [02:12<00:00,  1.08s/q]\n",
      "BR(BM25): 100%|██████████| 122/122 [02:59<00:00,  1.47s/q]\n",
      "BR(BM25): 100%|██████████| 124/124 [02:56<00:00,  1.42s/q]\n",
      "BR(BM25): 100%|██████████| 124/124 [02:47<00:00,  1.35s/q]\n",
      "BR(BM25): 100%|██████████| 124/124 [02:53<00:00,  1.40s/q]\n",
      "BR(BM25): 100%|██████████| 124/124 [02:28<00:00,  1.19s/q]\n",
      "BR(BM25): 100%|██████████| 124/124 [01:55<00:00,  1.07q/s]\n",
      "BR(BM25): 100%|██████████| 124/124 [01:55<00:00,  1.07q/s]\n",
      "BR(BM25): 100%|██████████| 124/124 [01:53<00:00,  1.10q/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "q072210934\n",
      "q072210934\n",
      "q072210934\n",
      "q072210934\n",
      "q072210934\n",
      "q072210934\n",
      "q072210934\n",
      "q072210934\n",
      "q072210934\n",
      "q072210934\n",
      "q072218453\n",
      "q072218453\n",
      "q072218453\n",
      "q072218453\n",
      "q072218453\n",
      "q072218453\n",
      "q072218453\n",
      "q072218453\n",
      "q072218453\n",
      "q072218453\n"
     ]
    }
   ],
   "source": [
    "for subcollection in [\"LT\", \"ST\"]:\n",
    "    index = pt.IndexFactory.of(os.path.join(\".\", config[\"index_dir\"] + f\"index_{subcollection}\"))\n",
    "    \n",
    "    topics = pt.io.read_topics(config[subcollection][\"test\"][\"topics\"])\n",
    "    topics = topics[topics[\"qid\"].isin(core_queries[f\"qid_{subcollection}\"])]\n",
    "\n",
    "    BM25 = pt.BatchRetrieve(index, wmodel=\"BM25\", verbose=True)\n",
    "    explicit_relevance_feedback = pt.apply.generic(ground_truth_ranking_from_training_data_transformer)\n",
    "    RM3 = pt.rewrite.RM3(index)\n",
    "    BO1 = pt.rewrite.Bo1QueryExpansion(index)\n",
    "    E5 = load_runs(\"IRC_E5_base\")\n",
    "    monoT5 = load_runs(\"IRC_BM25+monoT5\")\n",
    "\n",
    "    pipeline = [\n",
    "        (\"bm25\", BM25),\n",
    "        (\"exp-Rm3-bm25\", explicit_relevance_feedback >> RM3 >> BM25),\n",
    "        (\"exp-BO1-bm25\", explicit_relevance_feedback >> BO1 >> BM25),\n",
    "        (\"bm25-RM3-bm25\", BM25 >> RM3 >> BM25),\n",
    "        (\"bm25-BO1-bm25\", BM25 >> BO1 >> BM25),\n",
    "        # (\"E5-BO1-bm25\", E5 >> BO1 >> BM25),\n",
    "        (\"E5-RM3-bm25\", E5 >> RM3 >> BM25),\n",
    "        (\"monoT5-BO1-bm25\", monoT5 >> BO1 >> BM25),\n",
    "        (\"monoT5-RM3-bm25\", monoT5 >> RM3 >> BM25),\n",
    "        (\"E5\", E5),\n",
    "        (\"monoT5\", monoT5)\n",
    "    ]\n",
    "\n",
    "    all_runs = []\n",
    "\n",
    "    for name, system in pipeline:\n",
    "        run = system(topics)\n",
    "        run[\"system\"] = name\n",
    "        run[\"q0\"] = \"q0\"\n",
    "        run = run[['qid', \"q0\", 'docno', 'rank', 'score','system']]\n",
    "        all_runs.append(run)\n",
    "        run.to_csv(f\"results/fuse_learn/{name}.{subcollection}\", index=False, header=False, sep=\" \")\n",
    "\n",
    "    final_run = build_run(pd.concat(all_runs))\n",
    "    final_run[\"system\"] = \"fuse\"\n",
    "    final_run.to_csv(f\"results/fuse_learn/fuse.{subcollection}\", index=False, header=False, sep=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'all_runs' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_465/2061247667.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mruns\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mrun\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mall_runs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0mrun\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrename\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumns\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"query\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m\"query_string\"\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mrun\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrun\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrename\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumns\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"qid\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m\"query\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"docno\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m\"docid\"\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mret\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTrecRun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'all_runs' is not defined"
     ]
    }
   ],
   "source": [
    "runs = []\n",
    "for run in all_runs:\n",
    "    run = run.rename(columns = {\"query\": \"query_string\"})\n",
    "    run = run.rename(columns = {\"qid\": \"query\", \"docno\": \"docid\"})\n",
    "    ret = TrecRun()\n",
    "    ret.run_data = run\n",
    "    runs.append(run)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_qrels(subcollection):\n",
    "    qrels_file = config[subcollection][\"test\"][\"qrels\"]\n",
    "    qrels = pd.read_csv(qrels_file, names=[\"query\", \"Q0\", \"docid\", \"rel\"], sep=\" \")\n",
    "    qrels = qrels[qrels[\"query\"].isin(core_queries[f\"qid_{subcollection}\"])]\n",
    "\n",
    "    ret = TrecQrel()\n",
    "    ret.qrels_data = qrels\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 361,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_runs(subcollection):\n",
    "    return procedures.list_of_runs_from_path(\"results/fuse_learn\", f\"*.{subcollection}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 362,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fix_nan_in_runs(results_per_system):\n",
    "    runs_fixed = []\n",
    "    for system in results_per_system:\n",
    "        data = system.data.fillna(0)\n",
    "        system.data = data\n",
    "        runs_fixed.append(system)\n",
    "    return runs_fixed\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(measures):\n",
    "    for subcollection in [\"ST\", \"LT\"]:\n",
    "        runs = load_runs(subcollection)\n",
    "        qrels = load_qrels(subcollection)\n",
    "        \n",
    "        results_per_system = procedures.evaluate_runs(runs, qrels, per_query=True)\n",
    "        results_per_system = fix_nan_in_runs(results_per_system)\n",
    "\n",
    "        for measure in measures:\n",
    "            results = procedures.extract_metric_from_results(results_per_system, measure)\n",
    "            fig = procedures.plot_system_rank(results, display_metric=measure)\n",
    "            plt.title(f\"{measure} at {subcollection}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 11 runs in path results/fuse_learn\n",
      "Found 11 runs in path results/fuse_learn\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "evaluate(measures=[\"NDCG_10\", \"NDCG_1000\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.7.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}