wikisql_info.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "white-poultry",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from tqdm import tqdm\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "source": [
    "# Contents"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "compatible-string",
   "metadata": {},
   "outputs": [],
   "source": [
    "def stats_data(name):\n",
    "\n",
    "    n_lines = 0\n",
    "    data_lst = []\n",
    "    with open(f'data/{name}.jsonl') as f:\n",
    "        for l in f:\n",
    "            n_lines += 1\n",
    "\n",
    "    with open(f'data/{name}.jsonl') as f:\n",
    "        for l in tqdm(f):\n",
    "            data_lst.append(json.loads(l))\n",
    "    \n",
    "    # table id\n",
    "    table_id_lst = []\n",
    "    for d in data_lst:\n",
    "        table_id_lst.append(d['table_id'])\n",
    "\n",
    "    # the number of questions\n",
    "    nb_question = len(data_lst)\n",
    "    \n",
    "    return data_lst, list(set(table_id_lst)), nb_question"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "overall-receiver",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "56355it [00:00, 113983.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[TRAIN] the number of table id: 17984\n",
      "[TRAIN] the number of quesetion: 56355\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "name = 'train'\n",
    "train_lst, train_table_id_lst, train_nb_question = stats_data(name)\n",
    "print(f'[{name.upper()}] the number of table id: {len(train_table_id_lst)}')\n",
    "print(f'[{name.upper()}] the number of quesetion: {train_nb_question}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "secondary-water",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "8421it [00:00, 53232.25it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[DEV] the number of table id: 2630\n",
      "[DEV] the number of quesetion: 8421\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "name = 'dev'\n",
    "dev_lst, dev_table_id_lst, dev_nb_question = stats_data(name)\n",
    "print(f'[{name.upper()}] the number of table id: {len(dev_table_id_lst)}')\n",
    "print(f'[{name.upper()}] the number of quesetion: {dev_nb_question}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "graduate-afternoon",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "15878it [00:00, 144315.88it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[TEST] the number of table id: 5069\n",
      "[TEST] the number of quesetion: 15878\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "name = 'test'\n",
    "test_lst, test_table_id_lst, test_nb_question = stats_data(name)\n",
    "print(f'[{name.upper()}] the number of table id: {len(test_table_id_lst)}')\n",
    "print(f'[{name.upper()}] the number of quesetion: {test_nb_question}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "economic-finance",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[TOTAL] the number of table id:  25683\n"
     ]
    }
   ],
   "source": [
    "total_nb_table = len(train_table_id_lst) + len(dev_table_id_lst) + len(test_table_id_lst)\n",
    "print('[TOTAL] the number of table id: ',total_nb_table)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "suited-lingerie",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[TOTAL] the number of unique table id:  25683\n"
     ]
    }
   ],
   "source": [
    "total_unique_nb_table = len(set(train_table_id_lst + dev_table_id_lst + test_table_id_lst))\n",
    "print('[TOTAL] the number of unique table id: ',total_unique_nb_table)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sharing-protocol",
   "metadata": {},
   "source": [
    "## Word [TRAIN - DEV - TEST]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "friendly-treat",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_question = [\" \".join(d['question'].split()) for d in train_lst]\n",
    "dev_question = [\" \".join(d['question'].split()) for d in dev_lst]\n",
    "test_question = [\" \".join(d['question'].split()) for d in test_lst]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "federal-promotion",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_len_word = [len(q.split()) for q in train_question]\n",
    "dev_len_word = [len(q.split()) for q in dev_question]\n",
    "test_len_word = [len(q.split()) for q in test_question]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "greatest-riding",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[TRAIN]\n",
      "the number of words:  655840\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "count    56355.000000\n",
       "mean        11.637654\n",
       "std          4.486301\n",
       "min          3.000000\n",
       "25%          8.000000\n",
       "50%         11.000000\n",
       "75%         14.000000\n",
       "max         44.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('[TRAIN]')\n",
    "print('the number of words: ',sum(train_len_word))\n",
    "\n",
    "pd.Series(train_len_word).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "deluxe-force",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[DEV]\n",
      "the number of words:  98766\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "count    8421.000000\n",
       "mean       11.728536\n",
       "std         4.621717\n",
       "min         3.000000\n",
       "25%         8.000000\n",
       "50%        11.000000\n",
       "75%        14.000000\n",
       "max        58.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('[DEV]')\n",
    "print('the number of words: ',sum(dev_len_word))\n",
    "\n",
    "pd.Series(dev_len_word).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "heard-grove",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[TEST]\n",
      "the number of words:  185598\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "count    15878.000000\n",
       "mean        11.689004\n",
       "std          4.572430\n",
       "min          3.000000\n",
       "25%          8.000000\n",
       "50%         11.000000\n",
       "75%         14.000000\n",
       "max         43.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('[TEST]')\n",
    "print('the number of words: ',sum(test_len_word))\n",
    "\n",
    "pd.Series(test_len_word).describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sufficient-grill",
   "metadata": {},
   "source": [
    "## Word [TRAIN - DEV - TEST]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "remarkable-shark",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_len_character = [len(q) for q in train_question]\n",
    "dev_len_character = [len(q) for q in dev_question]\n",
    "test_len_character = [len(q) for q in test_question]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "original-sympathy",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[TRAIN]\n",
      "the number of characters:  3436711\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "count    56355.000000\n",
       "mean        60.983249\n",
       "std         23.601254\n",
       "min         12.000000\n",
       "25%         44.000000\n",
       "50%         57.000000\n",
       "75%         74.000000\n",
       "max        244.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('[TRAIN]')\n",
    "print('the number of characters: ',sum(train_len_character))\n",
    "\n",
    "pd.Series(train_len_character).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "preliminary-swimming",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[DEV]\n",
      "the number of characters:  514689\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "count    8421.000000\n",
       "mean       61.119701\n",
       "std        24.063118\n",
       "min        16.000000\n",
       "25%        43.000000\n",
       "50%        57.000000\n",
       "75%        74.000000\n",
       "max       275.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('[DEV]')\n",
    "print('the number of characters: ',sum(dev_len_character))\n",
    "\n",
    "pd.Series(dev_len_character).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "coordinate-wagon",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[TEST]\n",
      "the number of characters:  971670\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "count    15878.000000\n",
       "mean        61.195994\n",
       "std         23.978019\n",
       "min         17.000000\n",
       "25%         44.000000\n",
       "50%         57.000000\n",
       "75%         74.000000\n",
       "max        231.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('[TEST]')\n",
    "print('the number of characters: ',sum(test_len_character))\n",
    "\n",
    "pd.Series(test_len_character).describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "southeast-baghdad",
   "metadata": {},
   "source": [
    "# Tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "second-attention",
   "metadata": {},
   "outputs": [],
   "source": [
    "def stats_table(name):\n",
    "\n",
    "    n_lines = 0\n",
    "    table_lst = []\n",
    "    with open(f'data/{name}.tables.jsonl') as f:\n",
    "        for l in f:\n",
    "            n_lines += 1\n",
    "\n",
    "    with open(f'data/{name}.tables.jsonl') as f:\n",
    "        for l in tqdm(f):\n",
    "            table_lst.append(json.loads(l))\n",
    "    \n",
    "    # table id\n",
    "    table_id_lst = []\n",
    "    for d in table_lst:\n",
    "        table_id_lst.append(d['id'])\n",
    "\n",
    "    # header \n",
    "    header_lst = []\n",
    "    for idx, d in enumerate(table_lst):\n",
    "        header_lst.append(d['header'])\n",
    "    \n",
    "    # type\n",
    "    type_lst = []\n",
    "    for d in table_lst:\n",
    "        type_lst.append(d['types'])\n",
    "    \n",
    "    # row\n",
    "    nb_row_lst = [] \n",
    "    for d in table_lst:\n",
    "        nb_row_lst.append(len(d['rows']))\n",
    "        \n",
    "    return table_lst, table_id_lst, header_lst, type_lst, nb_row_lst                 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "impaired-andrew",
   "metadata": {},
   "source": [
    "## Train info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "equal-acoustic",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "18585it [00:00, 19062.85it/s]\n"
     ]
    }
   ],
   "source": [
    "name = 'train'\n",
    "train_table_info = stats_table(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "applied-setup",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of table in train:  18585\n",
      "the number of table id in train:  18585\n",
      "the number of total header:  118011\n",
      "\n",
      "description of the number of header in train\n",
      "count    18585.000000\n",
      "mean         6.349798\n",
      "std          1.727617\n",
      "min          5.000000\n",
      "25%          5.000000\n",
      "50%          6.000000\n",
      "75%          7.000000\n",
      "max         44.000000\n",
      "dtype: float64\n",
      "\n",
      "the number of unique header:  15305\n",
      "\n",
      "type value counts\n",
      "text    89005\n",
      "real    29006\n",
      "dtype: int64\n",
      "\n",
      "text    75.420935\n",
      "real    24.579065\n",
      "dtype: float64\n",
      "\n",
      "description of the number of row in train\n",
      "count    18585.000000\n",
      "mean        17.098144\n",
      "std         29.254070\n",
      "min          5.000000\n",
      "25%          7.000000\n",
      "50%         11.000000\n",
      "75%         18.000000\n",
      "max       1956.000000\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print('the number of table in train: ',len(train_table_info[0]))\n",
    "print('the number of table id in train: ',len(set(train_table_info[1])))\n",
    "print('the number of total header: ',sum(list(map(len,train_table_info[2]))))\n",
    "print()\n",
    "print('description of the number of header in train')\n",
    "print(pd.Series(list(map(len,train_table_info[2]))).describe())\n",
    "print()\n",
    "print('the number of unique header: ',len(set(sum(train_table_info[2], []))))\n",
    "print()\n",
    "print('type value counts')\n",
    "print(pd.Series(sum(train_table_info[3],[])).value_counts())\n",
    "print()\n",
    "print(pd.Series(sum(train_table_info[3],[])).value_counts(normalize=True) * 100)\n",
    "print()\n",
    "print('description of the number of row in train')\n",
    "print(pd.Series(train_table_info[4]).describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "changing-scholar",
   "metadata": {},
   "source": [
    "## Dev info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "mechanical-round",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2716it [00:00, 35332.29it/s]\n"
     ]
    }
   ],
   "source": [
    "name = 'dev'\n",
    "dev_table_info = stats_table(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "still-plaintiff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of table in dev:  2716\n",
      "the number of table id in dev:  2716\n",
      "the number of total header:  17130\n",
      "\n",
      "description of the number of header in dev\n",
      "count    2716.000000\n",
      "mean        6.307069\n",
      "std         1.621211\n",
      "min         5.000000\n",
      "25%         5.000000\n",
      "50%         6.000000\n",
      "75%         7.000000\n",
      "max        20.000000\n",
      "dtype: float64\n",
      "\n",
      "the number of unique header:  4025\n",
      "\n",
      "type value counts\n",
      "text    12824\n",
      "real     4306\n",
      "dtype: int64\n",
      "\n",
      "text    74.862814\n",
      "real    25.137186\n",
      "dtype: float64\n",
      "\n",
      "description of the number of row in dev\n",
      "count    2716.000000\n",
      "mean       16.480486\n",
      "std        20.628039\n",
      "min         5.000000\n",
      "25%         7.000000\n",
      "50%        11.000000\n",
      "75%        19.000000\n",
      "max       433.000000\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print('the number of table in dev: ',len(dev_table_info[0]))\n",
    "print('the number of table id in dev: ',len(set(dev_table_info[1])))\n",
    "print('the number of total header: ',sum(list(map(len,dev_table_info[2]))))\n",
    "print()\n",
    "print('description of the number of header in dev')\n",
    "print(pd.Series(list(map(len,dev_table_info[2]))).describe())\n",
    "print()\n",
    "print('the number of unique header: ',len(set(sum(dev_table_info[2], []))))\n",
    "print()\n",
    "print('type value counts')\n",
    "print(pd.Series(sum(dev_table_info[3],[])).value_counts())\n",
    "print()\n",
    "print(pd.Series(sum(dev_table_info[3],[])).value_counts(normalize=True) * 100)\n",
    "print()\n",
    "print('description of the number of row in dev')\n",
    "print(pd.Series(dev_table_info[4]).describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "weird-shore",
   "metadata": {},
   "source": [
    "## Test info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "spoken-oklahoma",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "5230it [00:00, 11675.32it/s]\n"
     ]
    }
   ],
   "source": [
    "name = 'test'\n",
    "test_table_info = stats_table(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cathedral-spanking",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of table in test:  5230\n",
      "the number of table id in test:  5230\n",
      "the number of total header:  33050\n",
      "\n",
      "description of the number of header in test\n",
      "count    5230.000000\n",
      "mean        6.319312\n",
      "std         1.628229\n",
      "min         5.000000\n",
      "25%         5.000000\n",
      "50%         6.000000\n",
      "75%         7.000000\n",
      "max        23.000000\n",
      "dtype: float64\n",
      "\n",
      "the number of unique header:  6414\n",
      "\n",
      "type value counts\n",
      "text    24798\n",
      "real     8252\n",
      "dtype: int64\n",
      "\n",
      "text    75.03177\n",
      "real    24.96823\n",
      "dtype: float64\n",
      "\n",
      "description of the number of row in test\n",
      "count    5230.000000\n",
      "mean       18.411090\n",
      "std        41.987367\n",
      "min         5.000000\n",
      "25%         7.000000\n",
      "50%        12.000000\n",
      "75%        19.000000\n",
      "max      1950.000000\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print('the number of table in test: ',len(test_table_info[0]))\n",
    "print('the number of table id in test: ',len(set(test_table_info[1])))\n",
    "print('the number of total header: ',sum(list(map(len,test_table_info[2]))))\n",
    "print()\n",
    "print('description of the number of header in test')\n",
    "print(pd.Series(list(map(len,test_table_info[2]))).describe())\n",
    "print()\n",
    "print('the number of unique header: ',len(set(sum(test_table_info[2], []))))\n",
    "print()\n",
    "print('type value counts')\n",
    "print(pd.Series(sum(test_table_info[3],[])).value_counts())\n",
    "print()\n",
    "print(pd.Series(sum(test_table_info[3],[])).value_counts(normalize=True) * 100)\n",
    "print()\n",
    "print('description of the number of row in test')\n",
    "print(pd.Series(test_table_info[4]).describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "impaired-smart",
   "metadata": {},
   "source": [
    "## Table [TRAIN - DEV - TEST]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "parallel-photographer",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[TRAIN] the number of table id:  18585\n",
      "[DEV] the number of table id:  2716\n",
      "[TEST] the number of table id:  5230\n"
     ]
    }
   ],
   "source": [
    "train_unique_nb_table = len(set(train_table_info[1]))\n",
    "dev_unique_nb_table = len(set(dev_table_info[1]))\n",
    "test_unique_nb_table = len(set(test_table_info[1]))\n",
    "\n",
    "print('[TRAIN] the number of table id: ',train_unique_nb_table)\n",
    "print('[DEV] the number of table id: ',dev_unique_nb_table)\n",
    "print('[TEST] the number of table id: ',test_unique_nb_table)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "sufficient-suspect",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[TOTAL] the number of unique header:  18881\n"
     ]
    }
   ],
   "source": [
    "total_unique_nb_header = len(set(sum(train_table_info[2],[]) + sum(dev_table_info[2],[]) + sum(test_table_info[2],[])))\n",
    "print('[TOTAL] the number of unique header: ',total_unique_nb_header)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "governmental-communist",
   "metadata": {},
   "source": [
    "## Header [TRAIN - DEV - TEST]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "imposed-minnesota",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[DEV-TRAIN] the number of unique header:  1296\n"
     ]
    }
   ],
   "source": [
    "only_dev_header = len(set(sum(dev_table_info[2],[])) - set(sum(train_table_info[2],[])))\n",
    "print('[DEV-TRAIN] the number of unique header: ',only_dev_header)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "speaking-linux",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[TEST-TRAIN] the number of unique header:  2419\n"
     ]
    }
   ],
   "source": [
    "only_test_header = len(set(sum(test_table_info[2],[])) - set(sum(train_table_info[2],[])))\n",
    "print('[TEST-TRAIN] the number of unique header: ',only_test_header)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "popular-harrison",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}