2022-12-16 20:40:41 +00:00
{
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"# How to count tokens with tiktoken\n",
"\n",
"[`tiktoken`](https://github.com/openai/tiktoken/blob/main/README.md) is a fast open-source tokenizer by OpenAI.\n",
"\n",
2023-03-02 20:52:26 +00:00
"Given a text string (e.g., `\"tiktoken is great!\"`) and an encoding (e.g., `\"cl100k_base\"`), a tokenizer can split the text string into a list of tokens (e.g., `[\"t\", \"ik\", \"token\", \" is\", \" great\", \"!\"]`).\n",
2022-12-16 20:40:41 +00:00
"\n",
2023-03-25 04:09:25 +00:00
"Splitting text strings into tokens is useful because GPT models see text in the form of tokens. Knowing how many tokens are in a text string can tell you (a) whether the string is too long for a text model to process and (b) how much an OpenAI API call costs (as usage is priced by token).\n",
2023-03-02 20:52:26 +00:00
"\n",
"\n",
"## Encodings\n",
"\n",
"Encodings specify how text is converted into tokens. Different models use different encodings.\n",
2022-12-16 20:40:41 +00:00
"\n",
"`tiktoken` supports three encodings used by OpenAI models:\n",
"\n",
"| Encoding name | OpenAI models |\n",
"|-------------------------|-----------------------------------------------------|\n",
2023-03-25 04:09:25 +00:00
"| `cl100k_base` | `gpt-4`, `gpt-3.5-turbo`, `text-embedding-ada-002` |\n",
"| `p50k_base` | Codex models, `text-davinci-002`, `text-davinci-003`|\n",
2023-03-02 20:52:26 +00:00
"| `r50k_base` (or `gpt2`) | GPT-3 models like `davinci` |\n",
"\n",
"You can retrieve the encoding for a model using `tiktoken.encoding_for_model()` as follows:\n",
"```python\n",
"encoding = tiktoken.encoding_for_model('gpt-3.5-turbo')\n",
"```\n",
2022-12-16 20:40:41 +00:00
"\n",
2023-03-25 04:09:25 +00:00
"Note that `p50k_base` overlaps substantially with `r50k_base`, and for non-code applications, they will usually give the same tokens.\n",
2022-12-16 20:40:41 +00:00
"\n",
2023-03-02 20:52:26 +00:00
"## Tokenizer libraries by language\n",
"\n",
"For `cl100k_base` and `p50k_base` encodings, `tiktoken` is the only tokenizer available as of March 2023.\n",
"- Python: [tiktoken](https://github.com/openai/tiktoken/blob/main/README.md)\n",
"\n",
"For `r50k_base` (`gpt2`) encodings, tokenizers are available in many languages.\n",
2022-12-16 20:40:41 +00:00
"- Python: [tiktoken](https://github.com/openai/tiktoken/blob/main/README.md) (or alternatively [GPT2TokenizerFast](https://huggingface.co/docs/transformers/model_doc/gpt2#transformers.GPT2TokenizerFast))\n",
"- JavaScript: [gpt-3-encoder](https://www.npmjs.com/package/gpt-3-encoder)\n",
"- .NET / C#: [GPT Tokenizer](https://github.com/dluc/openai-tools)\n",
"- Java: [gpt2-tokenizer-java](https://github.com/hyunwoongko/gpt2-tokenizer-java)\n",
"- PHP: [GPT-3-Encoder-PHP](https://github.com/CodeRevolutionPlugins/GPT-3-Encoder-PHP)\n",
"\n",
"(OpenAI makes no endorsements or guarantees of third-party libraries.)\n",
"\n",
"\n",
"## How strings are typically tokenized\n",
"\n",
"In English, tokens commonly range in length from one character to one word (e.g., `\"t\"` or `\" great\"`), though in some languages tokens can be shorter than one character or longer than one word. Spaces are usually grouped with the starts of words (e.g., `\" is\"` instead of `\"is \"` or `\" \"`+`\"is\"`). You can quickly check how a string is tokenized at the [OpenAI Tokenizer](https://beta.openai.com/tokenizer)."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## 0. Install `tiktoken`\n",
"\n",
2023-03-25 04:09:25 +00:00
"If needed, install `tiktoken` with `pip`:"
2023-03-02 20:52:26 +00:00
]
},
{
"cell_type": "code",
2023-03-20 17:55:35 +00:00
"execution_count": 1,
2023-03-02 20:52:26 +00:00
"metadata": {},
2023-03-20 17:55:35 +00:00
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Requirement already satisfied: tiktoken in /Users/ted/.virtualenvs/openai/lib/python3.9/site-packages (0.3.2)\n",
"Requirement already satisfied: regex>=2022.1.18 in /Users/ted/.virtualenvs/openai/lib/python3.9/site-packages (from tiktoken) (2022.10.31)\n",
"Requirement already satisfied: requests>=2.26.0 in /Users/ted/.virtualenvs/openai/lib/python3.9/site-packages (from tiktoken) (2.28.2)\n",
"Requirement already satisfied: charset-normalizer<4,>=2 in /Users/ted/.virtualenvs/openai/lib/python3.9/site-packages (from requests>=2.26.0->tiktoken) (2.0.9)\n",
2023-03-25 04:09:25 +00:00
"Requirement already satisfied: idna<4,>=2.5 in /Users/ted/.virtualenvs/openai/lib/python3.9/site-packages (from requests>=2.26.0->tiktoken) (3.3)\n",
2023-03-20 17:55:35 +00:00
"Requirement already satisfied: certifi>=2017.4.17 in /Users/ted/.virtualenvs/openai/lib/python3.9/site-packages (from requests>=2.26.0->tiktoken) (2021.10.8)\n",
"Requirement already satisfied: urllib3<1.27,>=1.21.1 in /Users/ted/.virtualenvs/openai/lib/python3.9/site-packages (from requests>=2.26.0->tiktoken) (1.26.7)\n",
"Note: you may need to restart the kernel to use updated packages.\n"
]
}
],
2023-03-02 20:52:26 +00:00
"source": [
"%pip install --upgrade tiktoken"
2022-12-16 20:40:41 +00:00
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. Import `tiktoken`"
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 1,
2022-12-16 20:40:41 +00:00
"metadata": {},
"outputs": [],
"source": [
"import tiktoken\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. Load an encoding\n",
"\n",
"Use `tiktoken.get_encoding()` to load an encoding by name.\n",
"\n",
"The first time this runs, it will require an internet connection to download. Later runs won't need an internet connection."
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 2,
2023-03-02 20:52:26 +00:00
"metadata": {},
"outputs": [],
"source": [
"encoding = tiktoken.get_encoding(\"cl100k_base\")\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Use `tiktoken.encoding_for_model()` to automatically load the correct encoding for a given model name."
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 3,
2022-12-16 20:40:41 +00:00
"metadata": {},
"outputs": [],
"source": [
2023-03-02 20:52:26 +00:00
"encoding = tiktoken.encoding_for_model(\"gpt-3.5-turbo\")"
2022-12-16 20:40:41 +00:00
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3. Turn text into tokens with `encoding.encode()`\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"The `.encode()` method converts a text string into a list of token integers."
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 4,
2022-12-16 20:40:41 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
2023-03-02 20:52:26 +00:00
"[83, 1609, 5963, 374, 2294, 0]"
2022-12-16 20:40:41 +00:00
]
},
2023-03-25 04:09:25 +00:00
"execution_count": 4,
2022-12-16 20:40:41 +00:00
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"encoding.encode(\"tiktoken is great!\")\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Count tokens by counting the length of the list returned by `.encode()`."
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 5,
2022-12-16 20:40:41 +00:00
"metadata": {},
"outputs": [],
"source": [
"def num_tokens_from_string(string: str, encoding_name: str) -> int:\n",
" \"\"\"Returns the number of tokens in a text string.\"\"\"\n",
" encoding = tiktoken.get_encoding(encoding_name)\n",
" num_tokens = len(encoding.encode(string))\n",
" return num_tokens\n"
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 6,
2022-12-16 20:40:41 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
2023-03-25 04:09:25 +00:00
"execution_count": 6,
2022-12-16 20:40:41 +00:00
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
2023-03-02 20:52:26 +00:00
"num_tokens_from_string(\"tiktoken is great!\", \"cl100k_base\")\n"
2022-12-16 20:40:41 +00:00
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## 4. Turn tokens into text with `encoding.decode()`"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"`.decode()` converts a list of token integers to a string."
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 7,
2022-12-16 20:40:41 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'tiktoken is great!'"
]
},
2023-03-25 04:09:25 +00:00
"execution_count": 7,
2022-12-16 20:40:41 +00:00
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
2023-03-02 20:52:26 +00:00
"encoding.decode([83, 1609, 5963, 374, 2294, 0])\n"
2022-12-16 20:40:41 +00:00
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Warning: although `.decode()` can be applied to single tokens, beware that it can be lossy for tokens that aren't on utf-8 boundaries."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"For single tokens, `.decode_single_token_bytes()` safely converts a single integer token to the bytes it represents."
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 8,
2022-12-16 20:40:41 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[b't', b'ik', b'token', b' is', b' great', b'!']"
]
},
2023-03-25 04:09:25 +00:00
"execution_count": 8,
2022-12-16 20:40:41 +00:00
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
2023-03-02 20:52:26 +00:00
"[encoding.decode_single_token_bytes(token) for token in [83, 1609, 5963, 374, 2294, 0]]\n"
2022-12-16 20:40:41 +00:00
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"(The `b` in front of the strings indicates that the strings are byte strings.)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## 5. Comparing encodings\n",
"\n",
2023-03-25 04:09:25 +00:00
"Different encodings vary in how they split words, group spaces, and handle non-English characters. Using the methods above, we can compare different encodings on a few example strings."
2022-12-16 20:40:41 +00:00
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 9,
2022-12-16 20:40:41 +00:00
"metadata": {},
"outputs": [],
"source": [
"def compare_encodings(example_string: str) -> None:\n",
" \"\"\"Prints a comparison of three string encodings.\"\"\"\n",
" # print the example string\n",
" print(f'\\nExample string: \"{example_string}\"')\n",
" # for each encoding, print the # of tokens, the token integers, and the token bytes\n",
" for encoding_name in [\"gpt2\", \"p50k_base\", \"cl100k_base\"]:\n",
" encoding = tiktoken.get_encoding(encoding_name)\n",
" token_integers = encoding.encode(example_string)\n",
" num_tokens = len(token_integers)\n",
" token_bytes = [encoding.decode_single_token_bytes(token) for token in token_integers]\n",
" print()\n",
" print(f\"{encoding_name}: {num_tokens} tokens\")\n",
" print(f\"token integers: {token_integers}\")\n",
" print(f\"token bytes: {token_bytes}\")\n",
" "
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 10,
2022-12-16 20:40:41 +00:00
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Example string: \"antidisestablishmentarianism\"\n",
"\n",
"gpt2: 5 tokens\n",
"token integers: [415, 29207, 44390, 3699, 1042]\n",
"token bytes: [b'ant', b'idis', b'establishment', b'arian', b'ism']\n",
"\n",
"p50k_base: 5 tokens\n",
"token integers: [415, 29207, 44390, 3699, 1042]\n",
"token bytes: [b'ant', b'idis', b'establishment', b'arian', b'ism']\n",
"\n",
"cl100k_base: 6 tokens\n",
"token integers: [519, 85342, 34500, 479, 8997, 2191]\n",
"token bytes: [b'ant', b'idis', b'establish', b'ment', b'arian', b'ism']\n"
]
}
],
"source": [
"compare_encodings(\"antidisestablishmentarianism\")\n"
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 11,
2022-12-16 20:40:41 +00:00
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Example string: \"2 + 2 = 4\"\n",
"\n",
"gpt2: 5 tokens\n",
"token integers: [17, 1343, 362, 796, 604]\n",
"token bytes: [b'2', b' +', b' 2', b' =', b' 4']\n",
"\n",
"p50k_base: 5 tokens\n",
"token integers: [17, 1343, 362, 796, 604]\n",
"token bytes: [b'2', b' +', b' 2', b' =', b' 4']\n",
"\n",
"cl100k_base: 7 tokens\n",
"token integers: [17, 489, 220, 17, 284, 220, 19]\n",
"token bytes: [b'2', b' +', b' ', b'2', b' =', b' ', b'4']\n"
]
}
],
"source": [
"compare_encodings(\"2 + 2 = 4\")\n"
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 12,
2022-12-16 20:40:41 +00:00
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Example string: \"お誕生日おめでとう\"\n",
"\n",
"gpt2: 14 tokens\n",
"token integers: [2515, 232, 45739, 243, 37955, 33768, 98, 2515, 232, 1792, 223, 30640, 30201, 29557]\n",
"token bytes: [b'\\xe3\\x81', b'\\x8a', b'\\xe8\\xaa', b'\\x95', b'\\xe7\\x94\\x9f', b'\\xe6\\x97', b'\\xa5', b'\\xe3\\x81', b'\\x8a', b'\\xe3\\x82', b'\\x81', b'\\xe3\\x81\\xa7', b'\\xe3\\x81\\xa8', b'\\xe3\\x81\\x86']\n",
"\n",
"p50k_base: 14 tokens\n",
"token integers: [2515, 232, 45739, 243, 37955, 33768, 98, 2515, 232, 1792, 223, 30640, 30201, 29557]\n",
"token bytes: [b'\\xe3\\x81', b'\\x8a', b'\\xe8\\xaa', b'\\x95', b'\\xe7\\x94\\x9f', b'\\xe6\\x97', b'\\xa5', b'\\xe3\\x81', b'\\x8a', b'\\xe3\\x82', b'\\x81', b'\\xe3\\x81\\xa7', b'\\xe3\\x81\\xa8', b'\\xe3\\x81\\x86']\n",
"\n",
"cl100k_base: 9 tokens\n",
"token integers: [33334, 45918, 243, 21990, 9080, 33334, 62004, 16556, 78699]\n",
"token bytes: [b'\\xe3\\x81\\x8a', b'\\xe8\\xaa', b'\\x95', b'\\xe7\\x94\\x9f', b'\\xe6\\x97\\xa5', b'\\xe3\\x81\\x8a', b'\\xe3\\x82\\x81', b'\\xe3\\x81\\xa7', b'\\xe3\\x81\\xa8\\xe3\\x81\\x86']\n"
]
}
],
"source": [
"compare_encodings(\"お誕生日おめでとう\")\n"
]
2023-03-02 20:52:26 +00:00
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## 6. Counting tokens for chat API calls\n",
"\n",
2023-03-25 04:09:25 +00:00
"ChatGPT models like `gpt-3.5-turbo` and `gpt-4` use tokens in the same way as older completions models, but because of their message-based formatting, it's more difficult to count how many tokens will be used by a conversation.\n",
2023-03-02 20:52:26 +00:00
"\n",
2023-03-20 17:55:35 +00:00
"Below is an example function for counting tokens for messages passed to `gpt-3.5-turbo-0301` or `gpt-4-0314`.\n",
2023-03-02 20:52:26 +00:00
"\n",
2023-03-25 04:09:25 +00:00
"Note that the exact way that messages are converted into tokens may change from model to model, and may even change over time for the same model. Therefore, the counts returned by the function below should be considered an estimate, not a guarantee."
2023-03-02 20:52:26 +00:00
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 13,
2023-03-02 20:52:26 +00:00
"metadata": {},
"outputs": [],
"source": [
"def num_tokens_from_messages(messages, model=\"gpt-3.5-turbo-0301\"):\n",
" \"\"\"Returns the number of tokens used by a list of messages.\"\"\"\n",
" try:\n",
" encoding = tiktoken.encoding_for_model(model)\n",
" except KeyError:\n",
2023-03-20 17:55:35 +00:00
" print(\"Warning: model not found. Using cl100k_base encoding.\")\n",
2023-03-02 20:52:26 +00:00
" encoding = tiktoken.get_encoding(\"cl100k_base\")\n",
2023-03-20 17:55:35 +00:00
" if model == \"gpt-3.5-turbo\":\n",
" print(\"Warning: gpt-3.5-turbo may change over time. Returning num tokens assuming gpt-3.5-turbo-0301.\")\n",
" return num_tokens_from_messages(messages, model=\"gpt-3.5-turbo-0301\")\n",
" elif model == \"gpt-4\":\n",
" print(\"Warning: gpt-4 may change over time. Returning num tokens assuming gpt-4-0314.\")\n",
" return num_tokens_from_messages(messages, model=\"gpt-4-0314\")\n",
" elif model == \"gpt-3.5-turbo-0301\":\n",
2023-03-25 04:09:25 +00:00
" tokens_per_message = 4 # every message follows <|start|>{role/name}\\n{content}<|end|>\\n\n",
2023-03-20 17:55:35 +00:00
" tokens_per_name = -1 # if there's a name, the role is omitted\n",
" elif model == \"gpt-4-0314\":\n",
" tokens_per_message = 3\n",
" tokens_per_name = 1\n",
2023-03-02 20:52:26 +00:00
" else:\n",
2023-03-20 17:55:35 +00:00
" raise NotImplementedError(f\"\"\"num_tokens_from_messages() is not implemented for model {model}. See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens.\"\"\")\n",
" num_tokens = 0\n",
" for message in messages:\n",
" num_tokens += tokens_per_message\n",
" for key, value in message.items():\n",
" num_tokens += len(encoding.encode(value))\n",
" if key == \"name\":\n",
" num_tokens += tokens_per_name\n",
2023-03-25 04:09:25 +00:00
" num_tokens += 3 # every reply is primed with <|start|>assistant<|message|>\n",
2023-03-20 17:55:35 +00:00
" return num_tokens\n"
2023-03-02 20:52:26 +00:00
]
},
{
"cell_type": "code",
2023-03-25 04:09:25 +00:00
"execution_count": 14,
2023-03-02 20:52:26 +00:00
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
2023-03-20 17:55:35 +00:00
"gpt-3.5-turbo-0301\n",
2023-03-25 04:09:25 +00:00
"127 prompt tokens counted by num_tokens_from_messages().\n",
"127 prompt tokens counted by the OpenAI API.\n",
2023-03-20 17:55:35 +00:00
"\n",
"gpt-4-0314\n",
2023-03-25 04:09:25 +00:00
"129 prompt tokens counted by num_tokens_from_messages().\n",
"129 prompt tokens counted by the OpenAI API.\n",
2023-03-20 17:55:35 +00:00
"\n"
2023-03-02 20:52:26 +00:00
]
}
],
"source": [
2023-03-20 17:55:35 +00:00
"# let's verify the function above matches the OpenAI API response\n",
2023-03-02 20:52:26 +00:00
"\n",
"import openai\n",
"\n",
2023-03-20 17:55:35 +00:00
"example_messages = [\n",
" {\n",
" \"role\": \"system\",\n",
" \"content\": \"You are a helpful, pattern-following assistant that translates corporate jargon into plain English.\",\n",
" },\n",
" {\n",
" \"role\": \"system\",\n",
" \"name\": \"example_user\",\n",
" \"content\": \"New synergies will help drive top-line growth.\",\n",
" },\n",
" {\n",
" \"role\": \"system\",\n",
" \"name\": \"example_assistant\",\n",
" \"content\": \"Things working well together will increase revenue.\",\n",
" },\n",
" {\n",
" \"role\": \"system\",\n",
" \"name\": \"example_user\",\n",
" \"content\": \"Let's circle back when we have more bandwidth to touch base on opportunities for increased leverage.\",\n",
" },\n",
" {\n",
" \"role\": \"system\",\n",
" \"name\": \"example_assistant\",\n",
" \"content\": \"Let's talk later when we're less busy about how to do better.\",\n",
" },\n",
" {\n",
" \"role\": \"user\",\n",
" \"content\": \"This late pivot means we don't have time to boil the ocean for the client deliverable.\",\n",
" },\n",
"]\n",
2023-03-02 20:52:26 +00:00
"\n",
2023-03-20 17:55:35 +00:00
"for model in [\"gpt-3.5-turbo-0301\", \"gpt-4-0314\"]:\n",
" print(model)\n",
" # example token count from the function defined above\n",
" print(f\"{num_tokens_from_messages(example_messages, model)} prompt tokens counted by num_tokens_from_messages().\")\n",
" # example token count from the OpenAI API\n",
" response = openai.ChatCompletion.create(\n",
" model=model,\n",
" messages=example_messages,\n",
" temperature=0,\n",
" max_tokens=1 # we're only counting input tokens here, so let's not waste tokens on the output\n",
" )\n",
" print(f'{response[\"usage\"][\"prompt_tokens\"]} prompt tokens counted by the OpenAI API.')\n",
" print()\n"
2023-03-02 20:52:26 +00:00
]
2022-12-16 20:40:41 +00:00
}
],
"metadata": {
"kernelspec": {
"display_name": "openai",
"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.9"
},
"orig_nbformat": 4,
"vscode": {
"interpreter": {
"hash": "365536dcbde60510dc9073d6b991cd35db2d9bac356a11f5b64279a5e6708b97"
}
}
},
"nbformat": 4,
"nbformat_minor": 2
}
