preprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 768,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import spacy\n",
    "import itertools\n",
    "import pickle\n",
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### save 10% for heldout test, use 90% for cv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 760,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total number of train example 3338\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv(\"./data/train.csv\", index_col=\"ID\")\n",
    "split_size = int(df.shape[0]/10); print(\"total number of train example\", len(df))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 764,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "holdout test num 333\n",
      "train val num 3005\n",
      "val num 333\n",
      "real train num 2672\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "test_idx = np.random.choice(df.index, size=split_size, replace=False); print(\"holdout test num\", len(test_idx))\n",
    "rest = np.array([i for i in df.index if i not in test_idx]); print(\"train val num\", len(rest))\n",
    "val_idx = np.random.choice(rest, size=split_size, replace=False); print(\"val num\", len(val_idx))\n",
    "train_idx = np.array([i for i in rest if i not in val_idx]); print(\"real train num\", len(train_idx))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 766,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3338"
      ]
     },
     "execution_count": 766,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_idx) + len(val_idx) + len(test_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 767,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df.loc[train_idx].to_csv(\"./data/train_real.csv\")\n",
    "df.loc[rest].to_csv(\"./data/train_val.csv\")\n",
    "df.loc[val_idx].to_csv(\"./data/val.csv\")\n",
    "df.loc[test_idx].to_csv(\"./data/holdout_test.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Vocabulary exploration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train vocab 1731\n",
      "test vocab 1041\n",
      "Combined vocab 1977\n",
      "test vocab not in train 246\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "df1 = pd.read_csv(\"./data/original_data/hw1_train.csv\")\n",
    "df2 = pd.read_csv(\"./data/original_data/hw1_test.csv\")\n",
    "\n",
    "splitter = lambda x: re.split(\" |'\", x.lower())\n",
    "\n",
    "vocab1 = set(list(itertools.chain.from_iterable(list(df1[\"UTTERANCE\"].apply(splitter)))))\n",
    "vocab2 = set(list(itertools.chain.from_iterable(list(df2[\"UTTERANCE\"].apply(splitter)))))\n",
    "vocab = sorted(list(vocab1.union(vocab2)))\n",
    "print(\"train vocab\", len(vocab1))\n",
    "print(\"test vocab\", len(vocab2))\n",
    "print(\"Combined vocab\", len(vocab))\n",
    "print(\"test vocab not in train\", len([i for i in vocab2 if i not in vocab1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.save(\"./data/vocab.npy\", np.array(vocab))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Turn labels into Manyhot representation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"./data/original_data/hw1_train.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "labels = sorted(list(set(\" \".join(df[\"CORE RELATIONS\"]).split(\" \"))))\n",
    "np.save(\"./data/labels.npy\", labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of classes: 46\n"
     ]
    }
   ],
   "source": [
    "label2idx = {text: i for i, text in enumerate(labels)}\n",
    "idx2label = {i: text for i, text in enumerate(labels)}\n",
    "print(\"number of classes:\", len(label2idx))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def lable_mapper(labels):\n",
    "    return \",\".join([str(label2idx[i]) for i in labels.split(\" \")])\n",
    "\n",
    "def label2manyhot(core_relations):\n",
    "    manyhot = [0] * len(labels)\n",
    "    for each_label in core_relations.split(\" \"):\n",
    "        idx = label2idx[each_label]\n",
    "        manyhot[idx] = 1\n",
    "    return \"\".join([str(i) for i in manyhot])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df[\"label\"] = df[\"CORE RELATIONS\"].apply(label2manyhot)\n",
    "df[\"text\"] = df[\"UTTERANCE\"]\n",
    "df[\"raw_text\"] = df[\"text\"]\n",
    "df[\"raw_label\"] = df[\"CORE RELATIONS\"]\n",
    "df[[\"ID\", \"text\", \"raw_text\", \"label\", \"raw_label\"]].set_index(\n",
    "    \"ID\").to_csv(\"./data/train.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"./data/original_data/hw1_test.csv\")\n",
    "\n",
    "df[\"text\"] = df[\"UTTERANCE\"]\n",
    "df[\"raw_text\"] = df[\"text\"]\n",
    "\n",
    "df[\"label\"] = [\"0\"] * df.shape[0]\n",
    "df[\"raw_label\"] = [\"dummy\"] * df.shape[0]\n",
    "df[[\"ID\", \"text\", \"raw_text\", \"label\", \"raw_label\"]].set_index(\n",
    "    \"ID\").to_csv(\"./data/test.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### fasttext vocab filtering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "vocab = np.load(\"./data/vocab.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000,20000,30000,40000,50000,60000,70000,80000,90000,100000,110000,120000,130000,140000,150000,160000,170000,180000,190000,200000,210000,220000,230000,240000,250000,260000,270000,280000,290000,300000,310000,320000,330000,340000,350000,360000,370000,380000,390000,400000,410000,420000,430000,440000,450000,460000,470000,480000,490000,500000,510000,520000,530000,540000,550000,560000,570000,580000,590000,600000,610000,620000,630000,640000,650000,660000,670000,680000,690000,700000,710000,720000,730000,740000,750000,760000,770000,780000,790000,800000,810000,820000,830000,840000,850000,860000,870000,880000,890000,900000,910000,920000,930000,940000,950000,960000,970000,980000,990000,1000000,1010000,1020000,1030000,1040000,1050000,1060000,1070000,1080000,1090000,1100000,1110000,1120000,1130000,1140000,1150000,1160000,1170000,1180000,1190000,1200000,1210000,1220000,1230000,1240000,1250000,1260000,1270000,1280000,1290000,1300000,1310000,1320000,1330000,1340000,1350000,1360000,1370000,1380000,1390000,1400000,1410000,1420000,1430000,1440000,1450000,1460000,1470000,1480000,1490000,1500000,1510000,1520000,1530000,1540000,1550000,1560000,1570000,1580000,1590000,1600000,1610000,1620000,1630000,1640000,1650000,1660000,1670000,1680000,1690000,1700000,1710000,1720000,1730000,1740000,1750000,1760000,1770000,1780000,1790000,1800000,1810000,1820000,1830000,1840000,1850000,1860000,1870000,1880000,1890000,1900000,1910000,1920000,1930000,1940000,1950000,1960000,1970000,1980000,1990000,2000000,"
     ]
    }
   ],
   "source": [
    "f = open(\"../fasttext/crawl-300d-2M-subword.vec\", \"r\", encoding=\"utf-8\")\n",
    "f_out = open(\"../fasttext/hw1_vocab.vec\", \"w\")\n",
    "f_out.write(\"{} {}\\n\".format(len(vocab), 300))\n",
    "d = {}\n",
    "for i, line in enumerate(f):\n",
    "    if i == 0:\n",
    "        continue\n",
    "    if i % 10000 == 0:\n",
    "        print(i, end=\",\")\n",
    "    word = line.split(\" \")[0]\n",
    "    if word in vocab:\n",
    "        d[word] = line.strip().split(' ')\n",
    "        f_out.write(line)\n",
    "    if len(d) == len(vocab):\n",
    "        break\n",
    "f.close()\n",
    "f_out.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pickle.dump(d, open(\"./data/vocab_ft.pkl\", \"wb\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_val_data, holdout_test_data, test_data = data_utils.prep_all_data(\n",
    "    data_path, train_val_file, holdout_test_file, test_file, \n",
    "    batch_size=BATCH_SIZE)\n",
    "vocab = train_val_data.text_field.vocab.itos\n",
    "ft_emb = pickle.load(open(\"./data/vocab_ft.pkl\", \"rb\"))\n",
    "emb_matrix = []\n",
    "for word in vocab:\n",
    "    if word in ft_emb:\n",
    "        vec = ft_emb[word][1:]\n",
    "        emb_matrix.append([float(i) for i in vec])\n",
    "    else:\n",
    "        vec = [np.random.normal() for i in range(300)]\n",
    "        emb_matrix.append(vec)\n",
    "emb_matrix = torch.tensor(emb_matrix)\n",
    "torch.save(emb_matrix, \"./data/emb_matrix_ft.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# same for label vocab\n",
    "label_vocab = np.load(\"./data/label_vocab.npy\")\n",
    "f = open(\"../fasttext/hw1_label_vocab.vec\", \"r\")\n",
    "d = {}\n",
    "for i, line in enumerate(f):\n",
    "    if i == 0:\n",
    "        continue\n",
    "    word, vec = line.split(\" \")[0], line.split(\" \")[1:]\n",
    "    vec = [float(i) for i in vec]\n",
    "    d[word] = vec\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(label_vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pickle.dump(d, open(\"./data/label_vocab_ft.pkl\", \"wb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### add hand craft features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"./data/original_data/hw1_train.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "labels = np.load(\"./data/labels.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "label_words = []\n",
    "for i in labels:\n",
    "    for j in i.split(\".\"):\n",
    "        if j not in label_words and j not in [\"NO_REL\", \"other\", \"gr\", \"rt\"]:\n",
    "            label_words.append(j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# max cosine simiarity between word and potential label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### create a feature to link label meaning to text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_df = pd.read_csv(\"./data/train_real.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "labels = np.load(\"./data/labels.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label_words = [re.split(\"\\.|_\", i) for i in labels]\n",
    "words = []\n",
    "for i in label_words:\n",
    "    words.extend(i)\n",
    "words = sorted(list(set(words)))\n",
    "    \n",
    "words.remove(\"REL\")\n",
    "words.remove(\"NO\")\n",
    "words.remove(\"gr\")\n",
    "words.remove(\"rt\")\n",
    "words.remove(\"nom\"), words.append(\"nomination\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.save(\"./data/label_vocab\", np.array(words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "vocab = np.load(\"./data/vocab.npy\")\n",
    "np.save(\"./data/label_vocab_restrict\", np.array([i for i in words if i in vocab]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000,"
     ]
    }
   ],
   "source": [
    "f = open(\"../fasttext/crawl-300d-2M-subword.vec\", \"r\", encoding=\"utf-8\")\n",
    "f_out = open(\"../fasttext/hw1_label_vocab.vec\", \"w\")\n",
    "f_out.write(\"{} {}\\n\".format(len(words), 300))\n",
    "d = {}\n",
    "for i, line in enumerate(f):\n",
    "    if i == 0:\n",
    "        continue\n",
    "    if i % 10000 == 0:\n",
    "        print(i, end=\",\")\n",
    "    word = line.split(\" \")[0]\n",
    "    if word in words:\n",
    "        d[word] = line.strip().split(' ')\n",
    "        f_out.write(line)\n",
    "    if len(d) == len(words):\n",
    "        break\n",
    "f.close()\n",
    "f_out.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['actor', 'amount', 'award', 'budget', 'by', 'category',\n",
       "       'character', 'companies', 'country', 'date', 'description',\n",
       "       'directed', 'director', 'genre', 'gross', 'language', 'locations',\n",
       "       'media', 'movie', 'music', 'of', 'other', 'person', 'picture',\n",
       "       'produced', 'production', 'rating', 'release', 'revenue', 'review',\n",
       "       'showing', 'star', 'starring', 'synopsis', 'trailer', 'winning',\n",
       "       'work', 'written'], dtype='<U11')"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.load(\"./data/label_vocab_restrict.np.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### see what labels co-occur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_df = pd.read_csv(\"./data/train_real.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_df[\"num_label\"] = train_df.raw_label.apply(lambda x: len(x.split(\" \")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    224\n",
       "Name: num_label, dtype: int64"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df[train_df.raw_label.apply(lambda x: \"other\" in x)].num_label.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    263\n",
       "Name: num_label, dtype: int64"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df[train_df.raw_label.apply(lambda x: \"NO_REL\" in x)].num_label.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "labels = np.load(\"./data/labels.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0]),)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(labels==\"NO_REL\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([37]),)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(labels==\"other\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.delete(np.arange(5), [0, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### N GRAM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1977"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# unigram is the same as vocab \n",
    "vocab = np.load(\"./data/vocab.npy\"); len(vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3338, 4)\n",
      "(1084, 4)\n",
      "(4422, 4)\n"
     ]
    }
   ],
   "source": [
    "# bigram\n",
    "df1 = pd.read_csv(\"./data/train.csv\", index_col=\"ID\")\n",
    "df2 = pd.read_csv(\"./data/test.csv\", index_col=\"ID\")\n",
    "df = pd.concat([df1, df2])\n",
    "print(df1.shape)\n",
    "print(df2.shape)\n",
    "print(df.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_ngram(sent, gram):\n",
    "    words = re.split(\"'| \", sent.lower())\n",
    "    if len(words) < gram:\n",
    "        return []\n",
    "    ngrams = []\n",
    "    for i in range(len(words)-(gram-1)):\n",
    "        ngrams.append(\"_\".join(words[i:i+gram]))\n",
    "    return ngrams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def save_ngram(df, n=2):\n",
    "    all_ngrams = []\n",
    "    for ngrams in df.raw_text.apply(lambda x: get_ngram(x, n)):\n",
    "        all_ngrams.extend(ngrams)\n",
    "    all_ngrams = np.array(sorted(list(set(all_ngrams))))\n",
    "    np.save(\"./data/{}grams.npy\".format(n), all_ngrams)\n",
    "    print(\"number of {} grams: {}\".format(n, len(all_ngrams)))\n",
    "    return all_ngrams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of 1 grams: 1977\n",
      "number of 2 grams: 6950\n",
      "number of 3 grams: 10113\n",
      "number of 4 grams: 10512\n"
     ]
    }
   ],
   "source": [
    "for n in range(1, 5):\n",
    "    save_ngram(df, n)"
   ]
  }
 ],
 "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}