Property_Prediction.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import openai\n",
    "import random\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "from sklearn.metrics import f1_score,accuracy_score\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem.Scaffolds import MurckoScaffold\n",
    "from rdkit.Chem import DataStructs\n",
    "from rdkit.Chem import rdMolDescriptors\n",
    "from rdkit import Chem\n",
    "import warnings\n",
    "from rdkit import RDLogger\n",
    "from steamship import Steamship\n",
    "import datetime\n",
    "import os "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.seed(42) \n",
    "#read bace dataset\n",
    "bace = pd.read_csv(\"/home/kguo2/PycharmProjects/GPT_test/Propperty_prediction/data/BACE.csv\")\n",
    "sample_size = 100\n",
    "bace_sample= bace.sample(sample_size)\n",
    "bace.drop(bace_sample.index, inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    57\n",
      "1    43\n",
      "Name: Class, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "##save sampled dataset\n",
    "\n",
    "bace_sample.to_csv(\"/home/kguo2/PycharmProjects/MolR/data/BACE/BACE_test.csv\",index = False)\n",
    "bace.to_csv(\"/home/kguo2/PycharmProjects/MolR/data/BACE/BACE_train.csv\",index =False)\n",
    "print(bace_sample['Class'].value_counts())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate result by GPT(Davinci-003,GPT-3.5, GPT-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_response_by_gpt4(prompt):\n",
    "    client = Steamship(workspace=\"gpt-4-g4d\")\n",
    "\n",
    "    # Create an instance of this generator\n",
    "    generator = client.use_plugin('gpt-4', config={\"temperature\":0.7, \"n\": 5})\n",
    "\n",
    "    # Generate text\n",
    "    task = generator.generate(text=prompt)\n",
    "    # Wait for completion of the task.\n",
    "    task.wait()\n",
    "    # Print the output\n",
    "#     message = task.output.blocks[0].text.strip()\n",
    "    message = task.output.blocks\n",
    "    message = [i.text.strip() for i in message]\n",
    "    return message\n",
    "\n",
    "def generate_response_by_gpt35(prompt, model_engine = \"gpt-3.5-turbo\"):\n",
    "    completion = openai.ChatCompletion.create(\n",
    "        model=model_engine, temperature=1, n=5, \n",
    "        messages=[{\"role\": \"user\", \"content\": prompt}],\n",
    "    )\n",
    "#     message = completion.choices[0].message.content.strip()\n",
    "\n",
    "    message = completion.choices\n",
    "    message = [i.message.content.strip() for i in message]\n",
    "    return message\n",
    "\n",
    "\n",
    "def generate_response_by_davinci(prompt, model_engine = 'text-davinci-003'):\n",
    "    completion = openai.Completion.create(\n",
    "      engine=model_engine,\n",
    "      prompt=prompt,\n",
    "      temperature=1.2,\n",
    "      max_tokens=256,\n",
    "#       top_p=1.0,\n",
    "      frequency_penalty=0.0,\n",
    "      presence_penalty=0.0, \n",
    "      n=5,\n",
    "    )\n",
    "#     message = completion.choices[0]['text'].strip()\n",
    "    \n",
    "    message = completion.choices\n",
    "    message = [i['text'].strip() for i in message]\n",
    "    return message"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sampling strategy: 1. random sample, 2.scaffold sample\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# random sampling\n",
    "def radom_sample_examples(bace,sample_size):\n",
    "    positive_examples = bace[bace[\"Class\"] == 1].sample(int(sample_size/2))\n",
    "    negative_examples = bace[bace[\"Class\"] == 0].sample(int(sample_size/2))\n",
    "    smiles = positive_examples[\"mol\"].tolist() + negative_examples[\"mol\"].tolist()\n",
    "    \n",
    "    class_label = positive_examples[\"Class\"].tolist() + negative_examples[\"Class\"].tolist()\n",
    "    #convert 1 to \"Yes\" and 0 to \"No\"\" in class_label\n",
    "    class_label = [\"Yes\" if i == 1 else \"No\" for i in class_label]\n",
    "    bace_examples = list(zip(smiles, class_label))\n",
    "    return bace_examples\n",
    "\n",
    "# scaffold sampling\n",
    "\n",
    "def top_k_scaffold_similar_molecules(target_smiles, bace_data, k):\n",
    "    #drop the target_smiles from the dataset\n",
    "    bace_data = bace_data[bace_data[\"mol\"] != target_smiles]\n",
    "    molecule_smiles_list = bace_data['mol'].tolist()\n",
    "    label_list = bace_data['Class'].tolist()\n",
    "    label_list = [\"Yes\" if i == 1 else \"No\" for i in label_list]\n",
    "\n",
    "    target_mol = Chem.MolFromSmiles(target_smiles)\n",
    "    if target_mol is not None:\n",
    "        target_scaffold = MurckoScaffold.GetScaffoldForMol(target_mol)\n",
    "    else:\n",
    "        print(\"Error: Unable to create a molecule from the provided SMILES string.\")\n",
    "        #drop the target_smiles from the dataset\n",
    "        return None\n",
    "\n",
    "    target_scaffold = MurckoScaffold.GetScaffoldForMol(target_mol)\n",
    "    target_fp = rdMolDescriptors.GetMorganFingerprint(target_scaffold, 2)\n",
    "    RDLogger.DisableLog('rdApp.warning')\n",
    "    warnings.filterwarnings(\"ignore\", category=UserWarning)\n",
    "    similarities = []\n",
    "    \n",
    "    for i,smiles in enumerate(molecule_smiles_list):\n",
    "        mol = Chem.MolFromSmiles(smiles)\n",
    "        try:\n",
    "            scaffold = MurckoScaffold.GetScaffoldForMol(mol)\n",
    "            scaffold_fp = rdMolDescriptors.GetMorganFingerprint(scaffold, 2)\n",
    "            tanimoto_similarity = DataStructs.TanimotoSimilarity(target_fp, scaffold_fp)\n",
    "            # print(tanimoto_similarity)\n",
    "            similarities.append((smiles, tanimoto_similarity,label_list[i]))\n",
    "        except:\n",
    "            continue\n",
    "    similarities.sort(key=lambda x: x[1], reverse=True)\n",
    "    top_5_similar_molecules = similarities[:k]\n",
    "    return top_5_similar_molecules"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sampling examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "randomly sampling examples [('O(C)c1cc(ccc1)-c1cc(ccc1)C1(N=C(N)N(C)C(=O)C1)C', 'Yes'), ('O(C)c1ccc(cc1)C1(N=C(N2C1=NCCC2)N)c1cc(ccc1)-c1cccnc1', 'Yes'), ('O(C)c1cc(ccc1OC)C(=O)N[C@@H](Cc1ccc([N+](=O)[O-])cc1)C(=O)N[C@H]([C@@H](O)C[C@H](C(=O)NCC(C)C)C)CC(C)C', 'No'), ('Clc1cc2CC([NH+]=C(N[C@@H](Cc3ccccc3)C=3NC(=O)C(=CN=3)C#N)c2cc1)(C)C', 'No')]\n",
      "scaffold sampling examples [('O1CC(N=C1N)(c1cc(ccc1)-c1cccnc1)c1ccc(OC)cc1', 0.4536082474226804, 'No'), ('Fc1cc(cc(c1)-c1cncnc1)C1(N=C(N)N(C)C1=O)c1ccc(OC(F)(F)F)cc1', 0.4444444444444444, 'No'), ('n1ccc(cc1)C1(N=C(N)c2c1cccc2)c1cc(ccc1)-c1cncnc1', 0.44339622641509435, 'No'), ('Fc1c2c(ccc1)C(N=C2N)(c1cc(C#N)c(OC)c(c1)C)c1cc(ccc1)-c1cncnc1', 0.44339622641509435, 'Yes')]\n"
     ]
    }
   ],
   "source": [
    "sample_size = 4\n",
    "target_smiles = \"O1C[C@]2(N=C1N)c1cc(ccc1Oc1c2cc(OCC(C)C)cc1)-c1cncnc1\"\n",
    "random_examples = radom_sample_examples(bace_sample,sample_size)\n",
    "print(\"randomly sampling examples\", radom_sample_examples(bace_sample,sample_size))\n",
    "print(\"scaffold sampling examples\", top_k_scaffold_similar_molecules(target_smiles, bace_sample,sample_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "openai.api_key = \"\" #enter your openai api key her"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_bace_prompt(input_smiles,pp_examples):\n",
    "    prompt = \"You are an expert chemist, your task is to predict the property of molecule using your experienced chemical property prediction knowledge.\\nPlease strictly follow the format, no other information can be provided. Given the SMILES string of a molecule, predict the molecular properties of a given chemical compound based on its structure, by analyzing wether it can inhibit(Yes) the Beta-site Amyloid Precursor Protein Cleaving Enzyme 1 (BACE1) or cannot inhibit(No) BACE1. Consider factors such as molecular weight, atom count, bond types, and functional groups in order to assess the compound's drug-likeness and its potential to serve as an effective therapeutic agent for Alzheimer's disease,please answer with only Yes or No. A few examples are provided in the beginning.\\n\"\n",
    "    for example in pp_examples:\n",
    "        prompt += f\"SMILES: {example[0]}\\nBACE-1 Inhibit: {example[-1]}\\n\"\n",
    "    prompt += f\"SMILES: {input_smiles}\\nBACE-1 Inhibit:\\n\"\n",
    "    return prompt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are an expert chemist, your task is to predict the property of molecule using your experienced chemical property prediction knowledge.\n",
      "Please strictly follow the format, no other information can be provided. Given the SMILES string of a molecule, predict the molecular properties of a given chemical compound based on its structure, by analyzing wether it can inhibit(Yes) the Beta-site Amyloid Precursor Protein Cleaving Enzyme 1 (BACE1) or cannot inhibit(No) BACE1. Consider factors such as molecular weight, atom count, bond types, and functional groups in order to assess the compound's drug-likeness and its potential to serve as an effective therapeutic agent for Alzheimer's disease,please answer with only Yes or No. A few examples are provided in the beginning.\n",
      "SMILES: S1(=O)(=O)N(c2cc(cc3n(cc(CC1)c23)CC)C(=O)NC([C@H](O)C[NH2+]CCC(F)(F)F)Cc1ccccc1)C\n",
      "BACE-1 Inhibit: Yes\n",
      "SMILES: s1cc(cc1)[C@@]1(N=C(N)N(C)C1=O)c1cc(ccc1)-c1cccnc1\n",
      "BACE-1 Inhibit: Yes\n",
      "SMILES: O(C)c1ccc(cc1CC)C1(N=C(N)N(C)C1=O)C12CC3CC(C1)CC(C2)C3\n",
      "BACE-1 Inhibit: No\n",
      "SMILES: Clc1cc(cc(F)c1)-c1cc(ccc1)C12N=C(OC1COCC2)N\n",
      "BACE-1 Inhibit: No\n",
      "SMILES: O1C[C@]2(N=C1N)c1cc(ccc1Oc1c2cc(OCC(C)C)cc1)-c1cncnc1\n",
      "BACE-1 Inhibit:\n",
      "\n"
     ]
    }
   ],
   "source": [
    "input_smiles = \"O1C[C@]2(N=C1N)c1cc(ccc1Oc1c2cc(OCC(C)C)cc1)-c1cncnc1\"\n",
    "example_prompt = create_bace_prompt(input_smiles,random_examples)\n",
    "print(example_prompt)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Few-shot In-context Learning "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_engine = ['gpt-4','gpt-3.5','davinci-003']\n",
    "# model_engine = [ 'davinci-003']\n",
    "sample_nums = [4,8]\n",
    "sample_methods = ['random','scaffold']\n",
    "detail_save_folder = '' # path to save the generated result \n",
    "paras = 0\n",
    "for sample_method in sample_methods:\n",
    "    for sample_num in sample_nums:\n",
    "        for model in model_engine:\n",
    "            if paras < 0:\n",
    "                paras += 1\n",
    "                continue\n",
    "            # elif paras == 3:\n",
    "            #     #terminate the program\n",
    "            #     exit()\n",
    "            detail_predict_file = detail_save_folder + 'test_{}_{}_{}_{}.csv'.format('bace', model, sample_num, sample_method)\n",
    "            log_file = detail_save_folder + 'test_{}_{}_{}_{}.log'.format('bace', model, sample_num, sample_method)\n",
    "            print(detail_predict_file)\n",
    "            print()\n",
    "            \n",
    "            if os.path.exists(detail_predict_file):\n",
    "                detail_results = pd.read_csv(detail_predict_file)\n",
    "                #convert the column to list\n",
    "                detail_results = detail_results.values.tolist()\n",
    "            else:\n",
    "                detail_results = []\n",
    "                \n",
    "                \n",
    "            now = datetime.datetime.now()\n",
    "            date_time_str = now.strftime(\"%Y-%m-%d %H:%M:%S\")\n",
    "            with open(log_file, \"a\") as file:\n",
    "                file.write(\"=\" * 30 + date_time_str + \"=\" * 30 + \"\\n\")\n",
    "                \n",
    "            if sample_method == 'random':\n",
    "                para_index = 0 \n",
    "                bace_examples = radom_sample_examples(bace,sample_num)\n",
    "                for i in tqdm(range(0, len(bace_sample))):\n",
    "                    # print(para_index)\n",
    "                    if para_index < 0:\n",
    "                        para_index += 1\n",
    "                        continue\n",
    "                    example = [(bace_sample.iloc[i]['mol'],bace_sample.iloc[i]['Class'])]\n",
    "                    pred_y = []\n",
    "                    generated_results = []\n",
    "                    for text in example:\n",
    "                        prompt = create_bace_prompt(text[0], bace_examples)\n",
    "                        with open(log_file, \"a\") as file:\n",
    "                            file.write(prompt + \"\\n\")\n",
    "                            file.write(\"=\" * 50 + \"\\n\")\n",
    "                        if model == 'davinci-003':\n",
    "                            generated_p = generate_response_by_davinci(prompt)    \n",
    "                        elif model == 'gpt-3.5-turbo':\n",
    "                            generated_p = generate_response_by_gpt35(prompt)\n",
    "                        elif model == 'gpt-4':\n",
    "                            generated_p = generate_response_by_gpt4(prompt)\n",
    "\n",
    "                        # generated_p = [1 if i == \"Yes\" else 0 for i in generated_p]\n",
    "                        generated_results.append(generated_p)\n",
    "                        detail_results.append([text[0]] + [text[-1]] + generated_p)\n",
    "                        \n",
    "                        print('training iterations',i)\n",
    "                        if (i+1) % 10 == 0:\n",
    "                            details_df = pd.DataFrame(detail_results, columns=['bace_smiles', 'class_label', 'pred_1', 'pred_2', 'pred_3', 'pred_4', 'pred_5'])\n",
    "                            details_df.to_csv(detail_predict_file, index=False)\n",
    "                            print('save file')\n",
    "                details_df = pd.DataFrame(detail_results, columns=['bace_smiles', 'class_label', 'pred_1', 'pred_2', 'pred_3', 'pred_4', 'pred_5'])\n",
    "                details_df.to_csv(detail_predict_file, index=False)\n",
    "            \n",
    "            elif sample_method == 'scaffold':\n",
    "                para_index = 0\n",
    "                for i in tqdm(range(0, len(bace_sample))):\n",
    "                    example = [(bace_sample.iloc[i]['mol'],bace_sample.iloc[i]['Class'])]\n",
    "                    pred_y = []\n",
    "                    generated_results = []\n",
    "                    # print(para_index)\n",
    "                    if para_index < 0:\n",
    "                        para_index += 1\n",
    "                        continue\n",
    "                    for text in example:\n",
    "                        bace_examples = top_k_scaffold_similar_molecules(text[0], bace, sample_num)\n",
    "                        prompt = create_bace_prompt(text[0],bace_examples)\n",
    "                        # print(prompt)\n",
    "                        with open(log_file, \"a\") as file:\n",
    "                            file.write(prompt + \"\\n\")\n",
    "                            file.write(\"=\" * 50 + \"\\n\")\n",
    "                        if model == 'davinci-003':\n",
    "                            generated_p = generate_response_by_davinci(prompt)    \n",
    "                        elif model == 'gpt-3.5-turbo':\n",
    "                            generated_p = generate_response_by_gpt35(prompt)\n",
    "                        elif model == 'gpt-4':\n",
    "                            generated_p = generate_response_by_gpt4(prompt)\n",
    "                        # convert the result to 1 if \"Yes\" in the result string else 0\n",
    "                \n",
    "                        # generated_p = [1 if \"Yes\" in i else 0 for i in generated_p]   \n",
    "                        generated_results.append(generated_p)\n",
    "                        detail_results.append([text[0]] + [text[-1]] + generated_p)\n",
    "                        \n",
    "                        print('training iterations',i)\n",
    "                        if (i+1) % 10 == 0:\n",
    "                            details_df = pd.DataFrame(detail_results, columns=['bace_smiles', 'class_label', 'pred_1', 'pred_2', 'pred_3', 'pred_4', 'pred_5'])\n",
    "                            details_df.to_csv(detail_predict_file, index=False)\n",
    "                details_df = pd.DataFrame(detail_results, columns=['bace_smiles', 'class_label', 'pred_1', 'pred_2', 'pred_3', 'pred_4', 'pred_5'])\n",
    "                details_df.to_csv(detail_predict_file, index=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zero-shot In-context learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_bace_prompt_zero_shot(input_text,pp_examples):\n",
    "    prompt = \"You are an expert chemist, your task is to predict the property of molecule using your experienced chemical property prediction knowledge.\\nPlease strictly follow the format, no other information can be provided. Given the SMILES string of a molecule, predict the molecular properties of a given chemical compound based on its structure, by analyzing wether it can inhibit(Yes) the Beta-site Amyloid Precursor Protein Cleaving Enzyme 1 (BACE1) or cannot inhibit(No) BACE1. Consider factors such as molecular weight, atom count, bond types, and functional groups in order to assess the compound's drug-likeness and its potential to serve as an effective therapeutic agent for Alzheimer's disease,please answer with only Yes or No. A template is provided in the beginning.\\n\"\n",
    "    for example in pp_examples:\n",
    "        prompt += f\"SMILES: {example[0]}\\nBACE-1 Inhibit: {example[-1]}\\n\"\n",
    "    prompt += f\"SMILES: {input_text}\\nBACE-1 Inhibit:\\n\"\n",
    "    return prompt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "label = []\n",
    "accs = []\n",
    "f1_scores_hiv = []\n",
    "epochs = 5\n",
    "performance_results = []\n",
    "detail_save_folder = '/home/kguo2/PycharmProjects/GPT_test/Propperty_prediction/code/bace/zero-shot/'\n",
    "model_engine = ['gpt-4']\n",
    "few_shot_examples = ([\"SMILES1\",\"Yes\"],[\"SMILES2\",\"No\"])\n",
    "paras = 0\n",
    "\n",
    "for model in model_engine:\n",
    "    if paras < 0:\n",
    "        paras += 1\n",
    "        continue\n",
    "    detail_predict_file = detail_save_folder + 'zero_shot_{}_{}.csv'.format('bace', model)\n",
    "    log_file = detail_save_folder + 'zero_shot_{}_{}.log'.format('bace', model)\n",
    "    print(detail_predict_file)\n",
    "    print()\n",
    "    \n",
    "    if os.path.exists(detail_predict_file):\n",
    "        detail_results = pd.read_csv(detail_predict_file)\n",
    "        #convert the column to list\n",
    "        detail_results = detail_results.values.tolist()\n",
    "    else:\n",
    "        detail_results = []\n",
    "\n",
    "    # append new date\n",
    "    # Get the current date and time\n",
    "    now = datetime.datetime.now()\n",
    "    # Convert the date and time to a string\n",
    "    date_time_str = now.strftime(\"%Y-%m-%d %H:%M:%S\")\n",
    "    with open(log_file, \"a\") as file:\n",
    "        file.write(\"=\" * 30 + date_time_str + \"=\" * 30 + \"\\n\")\n",
    "    para_index = 0\n",
    "    for i in tqdm(range(0, len(bace_sample))):\n",
    "        # print(para_index)\n",
    "        if para_index < 0:\n",
    "            para_index += 1\n",
    "            continue\n",
    "        example = [(bace_sample.iloc[i]['mol'],bace_sample.iloc[i]['Class'])]\n",
    "        pred_y = []\n",
    "        generated_results = []\n",
    "        for text in example:\n",
    "            prompt = create_bace_prompt_zero_shot(text[0],few_shot_examples)\n",
    "            # print(prompt)\n",
    "            with open(log_file, \"a\") as file:\n",
    "                file.write(prompt + \"\\n\")\n",
    "                file.write(\"=\" * 50 + \"\\n\")\n",
    "            if model == 'davinci-003':\n",
    "                generated_p = generate_response_by_davinci(prompt)    \n",
    "            elif model == 'gpt-3.5-turbo':\n",
    "                generated_p = generate_response_by_gpt35(prompt)\n",
    "            elif model == 'gpt-4':\n",
    "                generated_p = generate_response_by_gpt4(prompt)\n",
    "            print(generated_p)\n",
    "            \n",
    "            # generated_p = [1 if i == \"Yes\" else 0 for i in generated_p]   \n",
    "            generated_results.append(generated_p)\n",
    "            detail_results.append([text[0]] + [text[-1]] + generated_p)\n",
    "            \n",
    "            print('training iterations',i)\n",
    "            if (i+1) % 20 == 0:\n",
    "                details_df = pd.DataFrame(detail_results, columns=['bace_smiles', 'class_label', 'pred_1', 'pred_2', 'pred_3', 'pred_4', 'pred_5'])\n",
    "                details_df.to_csv(detail_predict_file, index=False)\n",
    "                print('save file')\n",
    "    details_df = pd.DataFrame(detail_results, columns=['bace_smiles', 'class_label', 'pred_1', 'pred_2', 'pred_3', 'pred_4', 'pred_5'])\n",
    "    details_df.to_csv(detail_predict_file, index=False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pygeo",
   "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.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}