notebooks/17_create_datasets_wo_averaging_split.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Initial size of logP dataset was $14111$\n",
    "\n",
    "2. After choosing most common logP values $13777$ rows have left\n",
    "\n",
    "3. In logP_wo_averaging dataset:\n",
    "\n",
    "Number of hydrophilic molecules =  1523\n",
    "\n",
    "Number of lipophilic molecules =  12236\n",
    "\n",
    "3. In logp_wo_logp_json_wo_averaging dataset:\n",
    "\n",
    "(dataset without data from logp.json)\n",
    "\n",
    "Number of molecules =  13688\n",
    "\n",
    "\n",
    "4. Initial size of logD dataset was $5584$\n",
    "\n",
    "5. After removing pH and dublicated SMILES-logP rows $5578$ samples left\n",
    "\n",
    "6. After choosing most common logD $5515$ rows left\n",
    "\n",
    "\n",
    "\n",
    "7. logD_Lipophilicity initially had size $4200$ molecules, after removing strange molecules $4198$ left\n",
    "\n",
    "8. After removing duplicated rows $4194$ samples have left\n",
    "\n",
    "9. After grouping same smiles and choosing most common logD $4166$ samples have left"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Choosing most common logP value from duplicated measurements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATASET_PATH = '../data/3_final_data/'\n",
    "SMILES_COLUMN = 'smiles'\n",
    "VALUE_COLUMN = 'logP'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = pd.read_csv(os.path.join(DATASET_PATH, 'logP.csv'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 14111 entries, 0 to 14110\n",
      "Data columns (total 2 columns):\n",
      " #   Column  Non-Null Count  Dtype  \n",
      "---  ------  --------------  -----  \n",
      " 0   smiles  14111 non-null  object \n",
      " 1   logP    14111 non-null  float64\n",
      "dtypes: float64(1), object(1)\n",
      "memory usage: 220.6+ KB\n"
     ]
    }
   ],
   "source": [
    "dataset.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_wo_averaging = dataset.groupby([SMILES_COLUMN]).agg(lambda x:x.value_counts().index[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 13777 entries, BrC(Br)(Br)Br to n1onc2c1NC1Nc3nonc3NC1N2\n",
      "Data columns (total 1 columns):\n",
      " #   Column  Non-Null Count  Dtype  \n",
      "---  ------  --------------  -----  \n",
      " 0   logP    13777 non-null  float64\n",
      "dtypes: float64(1)\n",
      "memory usage: 215.3+ KB\n"
     ]
    }
   ],
   "source": [
    "dataset_wo_averaging.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check logP values distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f0a68969190>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(dataset_wo_averaging[VALUE_COLUMN])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "logP\n",
       "(-20, -10]        0\n",
       "(-10, -5]         0\n",
       "(-5, 0]        1541\n",
       "(0, 10]       12236\n",
       "(10, 20]          0\n",
       "(20, 30]          0\n",
       "(30, 40]          0\n",
       "(40, 50]          0\n",
       "Name: logP, dtype: int64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ranges = [-20, -10, -5, 0, 10, 20, 30, 40, 50]\n",
    "dataset_wo_averaging[VALUE_COLUMN].groupby(pd.cut(dataset_wo_averaging[VALUE_COLUMN], ranges)).count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATASET_OTPUT_PATH = '../data/3_final_data/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_wo_averaging.to_csv(os.path.join(DATASET_OTPUT_PATH,'logp_wo_averaging.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split logp data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_test_validation_split(df):\n",
    "    from sklearn.model_selection import train_test_split\n",
    "    train_data, rest_data = train_test_split(df, test_size=0.3)\n",
    "    test_data, validation_data = train_test_split(rest_data, test_size=0.5)\n",
    "    return train_data.reset_index(drop=True), validation_data.reset_index(drop=True), test_data.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = '../data/3_final_data/'\n",
    "\n",
    "file = 'logp_wo_averaging'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logp_wo_averaging shape:  (13777, 2)\n",
      "SPLITTED SHAPES:\n",
      "\ttrain: (9643, 2)\n",
      "\tvalidation: (2067, 2)\n",
      "\ttest: (2067, 2)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv(os.path.join(DATA_PATH, file+'.csv'))\n",
    "\n",
    "\n",
    "print(file, 'shape: ', data.shape)    \n",
    "train, validation, test = train_test_validation_split(data)\n",
    "print('SPLITTED SHAPES:\\n\\ttrain: {0}\\n\\tvalidation: {1}\\n\\ttest: {2}\\n'.format(train.shape, validation.shape, test.shape))\n",
    "\n",
    "train.to_csv(DATA_PATH + 'split_data/' + file + '_train.csv')\n",
    "validation.to_csv(DATA_PATH + 'split_data/' + file + '_validation.csv')\n",
    "test.to_csv(DATA_PATH + 'split_data/' + file + '_test.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Count max atom num in logP dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = '../data/3_final_data/'\n",
    "\n",
    "file = 'logp_wo_averaging'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(os.path.join(DATA_PATH, file+'.csv'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from rdkit import Chem, DataStructs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "SMILES_COLUMN = 'smiles'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_atoms = [Chem.MolFromSmiles(smiles).GetNumAtoms() for smiles in data[SMILES_COLUMN]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "85"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(num_atoms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD7CAYAAABkO19ZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAAoM0lEQVR4nO3deXSc9X3v8fd3ZrRvtmRZtmTLC17A2GETmDQbgZALWXAWCJC0Jbe0NLel7W2S20t6T7kpt+0JvfeGpDekDSckh6QhQEnaOIkTkgaS0IQ4NsGAVxBe5UWWJVmyds3M9/4xj8hEjK2xNdJsn9c5OjzLb2a+GsafefR7fs/vMXdHREQKVyjbBYiIyMxS0IuIFDgFvYhIgVPQi4gUOAW9iEiBU9CLiBS4tILezK4zsz1m1m5md6XYX2Zmjwb7N5vZ0mB7iZk9ZGYvmtkuM/tEhusXEZEpTBn0ZhYG7geuB9YAt5rZmknNbgd63X0FcB9wb7D9JqDM3dcBlwF/OPElICIisyOSRpsrgHZ33wtgZo8AG4CdSW02AJ8Mlh8HPmdmBjhQZWYRoAIYA/rP9GLz5s3zpUuXnsWvICIizz777Al3b0y1L52gbwEOJa13AOtP18bdo2bWBzSQCP0NwFGgEvhzd++Z/AJmdgdwB0Braytbt25NoywREZlgZgdOt2+mT8ZeAcSAZmAZ8DEzWz65kbs/4O5t7t7W2JjyC0lERM5ROkF/GFictL4o2JayTdBNUwd0Ax8Evu/u4+5+HPgZ0DbdokVEJH3pBP0WYKWZLTOzUuAWYOOkNhuB24LlG4EnPTFb2kHgagAzqwKuBHZnonAREUnPlEHv7lHgTuAJYBfwmLvvMLN7zOyGoNmDQIOZtQMfBSaGYN4PVJvZDhJfGF929xcy/UuIiMjpWa5NU9zW1uY6GSsicnbM7Fl3T9k1ritjRUQKnIJeRKTAKehFRAqcgl5EpMClc2WsZNDDmw++ZtsH17dmoRIRKRYK+hyQKvxBXwAikhnquhERKXAKehGRAqegFxEpcAp6EZECp6AXESlwCnoRkQKnoBcRKXAKehGRAqegFxEpcAp6EZECp6AXESlwCnoRkQKXVtCb2XVmtsfM2s3srhT7y8zs0WD/ZjNbGmz/kJltS/qJm9nFmf0VRETkTKYMejMLk7jJ9/XAGuBWM1szqdntQK+7rwDuA+4FcPevufvF7n4x8DvAPnfflrnyRURkKukc0V8BtLv7XncfAx4BNkxqswF4KFh+HLjGzGxSm1uDx4qIyCxKJ+hbgENJ6x3BtpRt3D0K9AENk9rcDHz93MoUEZFzNSsnY81sPTDk7ttPs/8OM9tqZlu7urpmoyQRkaKRTtAfBhYnrS8KtqVsY2YRoA7oTtp/C2c4mnf3B9y9zd3bGhsb06lbRETSlE7QbwFWmtkyMyslEdobJ7XZCNwWLN8IPOnuDmBmIeADqH9eRCQrprxnrLtHzexO4AkgDHzJ3XeY2T3AVnffCDwIfNXM2oEeEl8GE94MHHL3vZkvvzjpBuMicjbSujm4u28CNk3adnfS8ghw02ke+2PgynMvUUREpkNXxoqIFDgFvYhIgVPQi4gUOAW9iEiBU9CLiBQ4Bb2ISIFT0IuIFDgFvYhIgVPQi4gUOAW9iEiBU9CLiBS4tOa6kdNLNcEYaJIxEckdOqIXESlwCnoRkQKnoBcRKXAKehGRAqeTsVlyuHeYvScGONgzREfvMGPROI4DML+mnOXzqmitr+TK5fVEwvo+FpFzp6CfZQOjUb79/BFePNwHQH1VKUsbKqkojWAG7s7h3mF++nIXP36pi3df1Mw/3HIxZpblykUkX6UV9GZ2HfBZEveM/aK7f2rS/jLgK8BlQDdws7vvD/a9DvgCUAvEgcuDWw8Wne+8cITP/PtLjEbjvO2CJi5fOpea8pKUbUfHYxwfGOUff/wKV5/fyHsvWTTL1YpIoZiyT8DMwsD9wPXAGuBWM1szqdntQK+7rwDuA+4NHhsB/hn4iLtfCFwFjGes+jzyrW2HufPh56ivKuXOt67g6vPnnzbkAcpKwnz87atpWzKXu/9tBx29Q7NYrYgUknQ6f68A2t19r7uPAY8AGya12QA8FCw/Dlxjib6GtwMvuPvzAO7e7e6xzJSeP7oHRvnrb+/k4sVz+MM3n0dTbXlajwuHjPtuvpi4Ox977HlicZ/hSkWkEKUT9C3AoaT1jmBbyjbuHgX6gAZgFeBm9oSZ/crM/mL6Jeefe76zk1Mj49z7/tcRDp1dX/vi+kr+5w0XsnlfDw/9fP/MFCgiBW2mh3NEgDcCHwr++14zu2ZyIzO7w8y2mtnWrq6uGS5pdj25u5NvbTvCH791BasX1JzTc9x02SIuWzKXR7ccmrqxiMgk6QT9YWBx0vqiYFvKNkG/fB2Jk7IdwE/d/YS7DwGbgEsnv4C7P+Dube7e1tjYePa/RY4aGI3yP/51O6uaqvmjq1ac8/OYGdevXcCezlMc7FZfvYicnXSCfguw0syWmVkpcAuwcVKbjcBtwfKNwJPu7sATwDozqwy+AN4C7MxM6blv47YjHO0b4e/eu47SyPT+eHr7mgUA/GDnsUyUJiJFZMr0Cfrc7yQR2ruAx9x9h5ndY2Y3BM0eBBrMrB34KHBX8Nhe4NMkviy2Ab9y9+9m/LfIUU/tOU7LnAouWzJ32s/V2lDJ6qYafrizMwOViUgxSWscvbtvItHtkrzt7qTlEeCm0zz2n0kMsSwqY9E4P28/wXsuacnYxU7Xrmni8z9u59oLmqgs07VuIpIeXVs/Q7Ye6GFwLMZVq+dn7DmvXdNE3GF356mMPaeIFD4F/Qz5yZ4uSsLG689ryNhzrmupo6m2jF1H+zP2nCJS+BT0M+THe7q4fGk91RnsYgmFjLdd0MTLnQOMx+IZe14RKWwK+hlwcmiMPZ2nuGp15oeKXrumibFYnFe6BjL+3CJSmBT0M+DlzkQIZ7J/fsLrz2ugLBJi11H104tIehT0M2BP5yma68pZOb86489dFgmzbF4V+08MZvy5RaQwKegzLBpPdKu8ZfX8GZtDvrW+kq6BUYbHim5+OBE5Bwr6DDvYM8RoND4j/fMTFtdXAnBIUxeLSBoU9Bk2MRfNlcszN6xyskVzKjDgUI+CXkSmpqDPsM7+EeZUlFBXcfqbikxXWUmYptpyHdGLSFoU9BnW2T+a9o1FpmNxfQWHeoaJu25GIiJnpqDPoFjc6To1S0E/t5Lh8RjdA2Mz/loikt8U9Bl0YmCUmDtNtWUz/lo6ISsi6VLQZ1Bn/wjArBzRN9aUURYJ6YSsiExJQZ9Bnf0jhCwRwjMtZMbiuZUKehGZkoI+gzr7R2moKqMkPDtv6+L6Co71jzAW1QRnInJ6CvoMOtY/QlPdzHfbTFhcX0nc4fDJ4Vl7TRHJPwr6DBmLxukdHJuVE7ETFs8NTsiq+0ZEziCtoDez68xsj5m1m9ldKfaXmdmjwf7NZrY02L7UzIbNbFvw808Zrj9nHD81ggNNNbN3RF9VFqGhqpSDCnoROYMp74phZmHgfuBaoAPYYmYb3X1nUrPbgV53X2FmtwD3AjcH+15x94szW3bumRhxs2AWu24AWuZWcKBbQS8ip5fOEf0VQLu773X3MeARYMOkNhuAh4Llx4FrbKambsxRnf2jlISN+qrSWX3dljkV9A2P0zOoC6dEJLV0gr4FOJS03hFsS9nG3aNAHzAxq9cyM3vOzH5iZm+aZr0561j/CPNrygnN8vfbwroKAHYc6ZvV1xWR/DHTJ2OPAq3ufgnwUeBhM6ud3MjM7jCzrWa2taura4ZLmhmd/SOzeiJ2QvOcRFfRjiO6YbiIpJZO0B8GFietLwq2pWxjZhGgDuh291F37wZw92eBV4BVk1/A3R9w9zZ3b2tsnLl53GfK0GiUUyPRWbkidrLK0ghzKksU9CJyWukE/RZgpZktM7NS4BZg46Q2G4HbguUbgSfd3c2sMTiZi5ktB1YCezNTeu44dmr2pj5Ipbmugh2H1XUjIqlNGfRBn/udwBPALuAxd99hZveY2Q1BsweBBjNrJ9FFMzEE883AC2a2jcRJ2o+4e0+Gf4es6+wfBbIY9HPK2dc9yMBoNCuvLyK5bcrhlQDuvgnYNGnb3UnLI8BNKR73DeAb06wx550YGKU0EqK2PK23M+Oa6ypwh11H+7l8aX1WahCR3KUrYzOgZ2CMhqrSGbsZ+FQWzglG3qj7RkRSUNBnwImBURqqZ3/EzYTa8gjzqkvZrhOyIpKCgn6aYnGndyhxRJ8tZsaa5jqNvBGRlBT009Q3PE7cyWrQA6xtruXlzlOMRmNZrUNEco+CfppODCRG3GSz6wbgwuY6onHnpWMDWa1DRHKPgn6auoM5Zhqqs3tEf2Fz4oJjTYUgIpMp6KepZ2CU0nCImrLsDK2c0FpfSU1ZhO0KehGZREE/TScGxmiozt7QygmhkHFBcy3bD+uErIj8JgX9NHUPjs361MSns7a5jt3H+onGdA9ZEfk1Bf00xOJO7+AYDVXZPRE7Yd2iWkbG47zSNZjtUkQkhyjop+HIyWFi7lk/ETthbXMdANt1hayIJFHQT8P+7sSRc64E/fLGaipKwjohKyK/QUE/DfuDe7XmStdNOGSsaa7VEb2I/IbsjgnMc/tPDFISNmqyNGtlKmuba/mXZzuIx51QyHh488HXtPng+tYsVCYi2aIj+mk40D1IQ1XZrN8n9kzWttQxNBZj7wmdkBWRBAX9NOzvHsqZoZUT1rYkTsjqClkRmaCgP0exuHOweyhnTsROWDG/mtJIiBc7FPQikqCgP0dH+4YZi8Vz5kTshJJwiAsW1mrkjYi8Kq2gN7PrzGyPmbWb2V0p9peZ2aPB/s1mtnTS/lYzGzCzj2eo7qw7MDHiJseO6CFxQnbH4X7icc92KSKSA6YMejMLA/cD1wNrgFvNbM2kZrcDve6+ArgPuHfS/k8D35t+ubljX3CyM9vz0KeyrqWOU6NRDvYMZbsUEckB6RzRXwG0u/tedx8DHgE2TGqzAXgoWH4cuMaCWb7M7D3APmBHRirOEQe6BxM3BK8oyXYprzFxQlbdNyIC6Y2jbwEOJa13AOtP18bdo2bWBzSY2Qjw34FrgYLptoFE101rfeWMDq1MNQY+HSubqikJGy8e7mNJfVWGqxKRfDPTJ2M/Cdzn7me87ZGZ3WFmW81sa1dX1wyXlBkHe4ZYUl+Z7TJSKouEWb2ghh2aslhESO+I/jCwOGl9UbAtVZsOM4sAdUA3iSP/G83s74E5QNzMRtz9c8kPdvcHgAcA2tracv4MortzoHuI3zpv3mnbnOvReKasba7je9uPcd3aBTl1QZeIzL50jui3ACvNbJmZlQK3ABsntdkI3BYs3wg86Qlvcvel7r4U+Azwd5NDPh91nRpleDzGkobcPKIHuLR1Ln3D43SdGs12KSKSZVMGvbtHgTuBJ4BdwGPuvsPM7jGzG4JmD5Lok28HPgq8ZghmITkQjGZpzeGgb1s6F4CD3Rp5I1Ls0pqNy903AZsmbbs7aXkEuGmK5/jkOdSXkybG0C+pr+ToyZEsV5PasnlVNFSVcqBnkMuX1We7HBHJIl0Zew4Odg8SMlg0N3eP6M2MS5fMfXUqZREpXgr6c3CgZ4iFdRWURnL77bt86Vx6Bsc4NTKe7VJEJItyO6ly1IHuIZbOy92j+QmXLUl02RzQUb1IUVPQn4ODPUO05sGFSGtbaomEjAPdmptepJgp6M9S/8g4PYNjOT20ckJZJMyiuRWvjhISkeKkoD9LB5NG3OSDJQ1VHDk5zFg0nu1SRCRLFPRnaaK/O5fH0CdbUl9J3KGjV0f1IsVKQX+WDvQk+ruXNOR+Hz38+gtJ3TcixUtBf5YOdg/RUFVKdVla15plXWVphPk1ZTohK1LEFPRn6UD3UF6ciE22pKGSgz1DxD3n54sTkRmgoD9LB3uG8qbbZsLyxmpGxuN0qPtGpCjlR/9DjhiNxjjSN0xrnoy4mbByfjUG7OkcoLWh6rRTKH9wfevsFiYis0JH9Geho3cYd/Ku66ayNEJrfSUvdZ7KdikikgUK+rMwcUIz34IeYNWCGg6fHNa8NyJFSEF/Fl4dQ58H0x9MtrqpBoCXO894V0cRKUAK+rNwoHuIqtIw86pLs13KWVtYV05NWYQ96r4RKToK+rNwoHuQ1oYqLA/vwWpmrGqq4eXjp4jFNcxSpJgo6M/C/u4hls/Lv26bCasW1DAyHueQhlmKFJW0gt7MrjOzPWbWbmavuR+smZWZ2aPB/s1mtjTYfoWZbQt+njez92a4/lkzHotzsCc/5qE/nRWN1YQMdd+IFJkpg97MwsD9wPXAGuBWM1szqdntQK+7rwDuA+4Ntm8H2tz9YuA64Atmlpdj9zt6h4nFnaV5drFUsorSMK31VRpmKVJk0jmivwJod/e97j4GPAJsmNRmA/BQsPw4cI2ZmbsPuXs02F4O5G3n8P4TiaGVy/K46wZg9YIajvaNcHJoLNuliMgsSSfoW4BDSesdwbaUbYJg7wMaAMxsvZntAF4EPpIU/HllX4EE/ZqFtQDsPNqf5UpEZLbM+MlYd9/s7hcClwOfMLPyyW3M7A4z22pmW7u6uma6pHOyv3uQmvII9VX5N7QyWWNNGfNryth+WEEvUizSCfrDwOKk9UXBtpRtgj74OqA7uYG77wIGgLWTX8DdH3D3Nndva2xsTL/6WbTvxCDL5uXn0MrJ1rbUcaB7UFfJihSJdIJ+C7DSzJaZWSlwC7BxUpuNwG3B8o3Ak+7uwWMiAGa2BDgf2J+RymfZvhODeX0iNtna5jocdd+IFIspR8C4e9TM7gSeAMLAl9x9h5ndA2x1943Ag8BXzawd6CHxZQDwRuAuMxsH4sAfufuJmfhFZtJoNMaRk8O879JF2S7ltE43I2UqTbVlNFSVsuNwP+uXNcxgVSKSC9Ia6ujum4BNk7bdnbQ8AtyU4nFfBb46zRqz7lDPEHGHZXk8hj6ZmbG2pY6nX+5iaDRKZZ7cLUtEzo2ujE3DvhOJK0mXzavOciWZc2FzLXGHXcfUfSNS6BT0aXh1DH2B9NEDtMypYE5liUbfiBQB/c2ewuT+7h/s7KSyNExdZUmWKso8M2Ntcx3P7O1mZDxGeUk42yWJyAzREX0augdGacjz8fOprG2uJRZ3dqv7RqSgKejT0D04xrzqsmyXkXGL6iupLY+o+0akwCnopzAWjdM3PE5DAQZ9yIwLW+p4qfMUo+OxbJcjIjNEQT+FnsHE5F/5eFepdKxtriMad01dLFLAFPRTODEwClCQR/SQuNF5TVmE7Yf7sl2KiMwQBf0UuoOgn1eAJ2Mh0X2zprmWPZ2nGBrLy4lFRWQKCvopnBgco7osQlkBDz9c21LHeMz5yZ7cnDlURKZHQT+FrlOjBTniJtnShiqqSsNs2n4s26WIyAxQ0J+Bu9PZP0JTbWEHfThkrGmu48ldnYxo9I1IwVHQn0H/SJTRaJym2tfcK6XgrG2pZXAsxo/VfSNScBT0Z9DZPwJQFEG/fF419VWlfPfFo9kuRUQyTEF/Bq8GfU1hd91AovvmurUL+NGuTobH1H0jUkg0qdkZdPaPUlMWeXW+9rO5uUc+ete6hTy8+SBP7TnOO9YtzHY5IpIhOqI/g+OnRphf4Cdik61f3sC86lK+88KRbJciIhmkoD+NuDvH+0eLon9+QjhkXL92IU/uPs7gqC6eEikUaQW9mV1nZnvMrN3M7kqxv8zMHg32bzazpcH2a83sWTN7Mfjv1Rmuf8acHBpnLBanqaZ4gh7gXa9byMh4nB/tPp7tUkQkQ6YMejMLA/cD1wNrgFvNbM2kZrcDve6+ArgPuDfYfgJ4t7uvA24jj+4fe/zVETfF03UD0La0nvk1ZXxX3TciBSOdI/orgHZ33+vuY8AjwIZJbTYADwXLjwPXmJm5+3PuPpEYO4AKM8uL5JwYcTO/iLpuINF98451C3lqTxenRsazXY6IZEA6Qd8CHEpa7wi2pWzj7lGgD2iY1Ob9wK/cffTcSp1dnadGqasoKcpb7L37ooWMReN8X1MiiBSEWRleaWYXkujOeftp9t8B3AHQ2to6GyVNqRimPjidS1vnsnxeFY9tPcRNbYtTDiv94Prc+P8kIlNL54j+MLA4aX1RsC1lGzOLAHVAd7C+CPhX4Hfd/ZVUL+DuD7h7m7u3NTY2nt1vMAPi7nSdGi26E7ETzIwPXL6YLft7eaVrINvliMg0pRP0W4CVZrbMzEqBW4CNk9psJHGyFeBG4El3dzObA3wXuMvdf5ahmmdcz8AY0bgXXf98svdd2kI4ZDy25dDUjUUkp00Z9EGf+53AE8Au4DF332Fm95jZDUGzB4EGM2sHPgpMDMG8E1gB3G1m24Kf+Rn/LTKs81RxjrhJNr+mnGvOn883ftVBLO7ZLkdEpiGtPnp33wRsmrTt7qTlEeCmFI/7G+BvplnjrHt1xE2Rdt1MuPnyxfxgZye7j/VzYXNdtssRkXOkK2NT6OwfZW5lCaWR4n573rKqkabaMrbu7812KSIyDcWdZKdxtG+YBXUV2S4j6yLhEDdetoiXOk/RN6wx9SL5SkE/Sd/QOCcGxlg8V0EPcHNbYhjl5r3dWa5ERM6Vgn6S5ztOArBobmV2C8kRrQ2VXNhSxzN7uzVPvUieUtBP8vyhkxiwSEf0r7pqVSOj0TjP6KheJC8p6CfZdugk82rKinLqg9NpnlPB6qYafv7KCUajOqoXyTcK+iTuzvMdJ9U/n8JbVzcyNBZjy76ebJciImdJQZ+ko3eYEwNj6p9PobWhiuXzqni6/QTjsXi2yxGRs6CgTzJxInaxgj6lq1bP59RIlF/qqF4kryjok2w7eJLSSIgFdcV9RezpnNdYxcr51fxwVydHTg5nuxwRSZOCPsnzHSdZ21xLOGTZLiUnmRkbLm7B3bn7W9tx1xw4IvlAQR8Yj8V58XAfFy+em+1Sclp9VSlvu6CJf991nO/pxiQieWFWbjySD17qPMXIeJyLFtcxOKohhGfyW+fN41DvEP9z4w7ecN486ipLXt2nm5SI5B4d0Qe2HToJwCU6op9SOGR86n2vo2dwjP/2+POaxlgkxxV90D+8+SAPbz7IN391mMrSME+/3JXtkvLC2pY6/uqdF/CDnZ389bd3qL9eJIep6yZwqGeIxXMrMSveE7Gpul3O5MNvWMaRvhEe+OleFtZV8F+uOu+snlddOiKzQ0EPDIxGOX5qlEsWz8l2KXnnruvO51jfCPd+fzdzk/rqRSR3FH3XDcC+E4MALGusznIl+ScUMv73Ta/jzasaueubL/LDnZ3qxhHJMWkFvZldZ2Z7zKzdzO5Ksb/MzB4N9m82s6XB9gYze8rMBszscxmuPWP2nRigNByiZY7muDkXZZEwD97WxgfaFvHUnuP8y7MdRDVNgkjOmDLozSwM3A9cD6wBbjWzNZOa3Q70uvsK4D7g3mD7CPBXwMczVvEM2Ns1yJKGSl0oNQ0l4RD3vv91vH1NE9sOneQLP93L0T5dPSuSC9I5or8CaHf3ve4+BjwCbJjUZgPwULD8OHCNmZm7D7r7f5AI/Jw00T+/fF5VtkvJe2bGVavn86H1rZwcHuf+p9r5wY5jmgRNJMvSORnbAhxKWu8A1p+ujbtHzawPaABOZKLImaT++cy7sLmOZQ1VbNp+jB+/1MULh/u4fu0C1iysLepRTSLZkhMnY83sDjPbamZbu7pmdxy7+udnRmVZhBsvW8TvvWEZkZDxtc0H+eJ/7ONYX87+cSdSsNIJ+sPA4qT1RcG2lG3MLALUAWnfd87dH3D3Nndva2xsTPdhGaH++Zm1Yn41f3L1Sm64qJnO/hH+8SfttB8fyHZZIkUlnaDfAqw0s2VmVgrcAmyc1GYjcFuwfCPwpOfBGLsTA6Pqn58F4ZBx5fIG/uyalTRUlfHQM/vZdbQ/22WJFI0pg97do8CdwBPALuAxd99hZveY2Q1BsweBBjNrBz4KvDoE08z2A58GPmxmHSlG7GTNxA001D8/O2rKS/j9Ny1jYV05X9t8gG8/fyTbJYkUhbSujHX3TcCmSdvuTloeAW46zWOXTqO+GfWLvd3qn59llaURfu8Ny/jKM/v56GPbWNJQyesWzcl2WSIFLSdOxmbLM690q38+C8pLwvz2lUtorC7jzoefo39kPNsliRS0og36wyeHefn4ACvmq9smGypLI/zDrZdw+OQwn/jmi5o2QWQGFe2kZk/tPg7A6qaaLFeSn852pstU2pbW87G3r+Lvv7+HN5w3T7NZisyQoj2if2r3cRbXV9BYU5btUoraR958Hm9e1cgnv72DZw/0ZrsckYJUlEE/Mh7jZ6+c4OrV83WlZpaFQsZnb76YhXXl/OFXt9LRO5TtkkQKTlEG/TN7uxkZj/PW8+dnuxQB5laV8uBtlzMajfP7D21lYDSa7ZJECkpR9tE/tfs4FSVhrlzewDd/NfkiX8mGFfOr+fyHLuXDX97C+z//cz64vpWS8K+PQ9R/L3Luiu6I3t15cvdx3rBiHuUl4WyXI0netLKRezZcyJ7OU3zx6b0adimSIUUX9O3HB+joHeZqddvkpA+tX8IHr2jlWP8In3+qXX32IhlQdEH/ZDCs8q3nz+7kaZK+tS11fOQt5xEKGQ/8dC9Pv9xFLK5x9iLnqiiD/oKFtSys07QHuWxhXQV/dNUKVjbV8L3tx7jxn36uWS9FzlFRBf2Rk8NsPdDLNeq2yQvVZRF+e30rN7ctZt+JQd7xD0/zf3+wh6ExjcoRORtFNermyz/bB8CtGsGRE9K5utbMuGjxHD7+n1bzt9/dyf97sp3Hn+3gL99xAe9ct5CQ5ikSmVLRHNH3j4zz9V8e4p3rFmq2yjzUWFPGZ265hH/5yOuZW1nKn3z9Od5230/46i8O6AhfZApFc0T/6C8PMTAa5Q/etDzbpcg0XL60nm//yRv59vNHePA/9vFX/7adv/3uTtY217G2pY7zGqv5ndcvyXaZIjmlKIJ+PBbnyz/bx5XL61m3qC7b5cg0hUPGey5pYcPFzXzqe7v5xd5uXjjcx9YDvVSUhHm+4yTvWLeAN6yYR1lE10qIFEXQb3rxKEf6Rvhf71mb7VLkHJ2uP39JQxVLGqoYj8VpPz7A9sN9fOeFIzz+bAdlkRAXLKxlXUsdK+dX87u/tXR2ixbJEQUf9LG488BP97K8sYq3rtZom0JVEk6E+gULa4nG47xyfJDtR/rYeaSfbYdOUhYJsXl/D29Z1chbVjXSVFue7ZJFZk1BB/3IeIw//fpz7DjSz6c/cJFGaBSJSCjE6gU1rF5Qw3sudl7pGuDFw31s2dfDd184CkDLnArOm1/NisZqmmrLKIuEKCsJEzYj5k4s7kRCRk15CTXlEeZWltI8p5z6qlLNeCp5J62gN7PrgM8CYeCL7v6pSfvLgK8AlwHdwM3uvj/Y9wngdiAG/Km7P5Gx6s+gb3icP/jKVrbs7+GT717D+y5dNBsvKzkmHDJWNdWwqqmGW69YzO5jp3j65S52HOmn/fgAv9yXmMk0XRUlYRbWlTOvuoz6qlLmVpVSWRoOfiLUlEeoqyihtqKEORUlzKksoba8hJJIiJBByIyhsRgDI1FOjY7TNzROz9AYvUPj9A8HPyPjDI7GGBmPse/EIDF33En84JDqImGDhXXlREIhImGjqjRCZWmYmvISmmrLWFBXzsK6ChbWlbOgrvw3JoyTwjdl0JtZGLgfuBboALaY2UZ335nU7Hag191XmNktwL3AzWa2BrgFuBBoBv7dzFa5eyzTvwhA39A42zpOsu3gSTY+f5iDPUN89pZLuOGi5pl4OckzX//lIQCqy0pYv6yB9csaiLszHosTjTnRuBOPO6GQYQbxuDMSjTM6HmNwNErv0Dgnh8boG4nSNTDK/u5BBsdijEfjjMfiKfP3bJWXhKgpL6GqNEx5SZjh8RjhkGEkagphEILJf1PEHeJxGI7FGBuOc2hsiKGxGH3D4wyN/eY/NyMxXLW6PEJVaYSK0jAlYSMcChEJGRWlYapLI1SVRaitiFBbXkJdRQkVpeHEXz6RMKFQ8vMFtZkRDvHq85SEE186kZARskSbVx8TrBiJL+PEY41I2CgJhRLLIcv5v8I9+OtvLBZndDzxORiPO9FYnGjcCSf/XuEQZZEQpZEQJaHQrP5u6RzRXwG0u/teADN7BNgAJAf9BuCTwfLjwOcs8X9yA/CIu48C+8ysPXi+ZzJT/q/9cl8PH/hC4mnNErcI/NKHL+dNKzWnjZxeyIyySJiyaXZiujvjMWdkPMbweOJo/Ipl9ZwcGqdveJxY3Im5E3dn55F+yiNhSiMhKssSfwlUloapKAnPyJH2yHgi8PuHE7WcHB6nsbqMgbEoQ6NRhsZijI7HicZjHO8fYSwWZywaZySa+G82hYzf+KIzS3yxwMTyzEr+8p74i8qDP6picZ/WHEwhS3QzJv9e169bwKc/cPF0y36NdD7eLcChpPUOYP3p2rh71Mz6gIZg+y8mPbZl8guY2R3AHcHqgJntSaOuecCJ0+3cDzzx52k8S+E54/tSxPS+pKb3JbWsvC+7gftuPueHn/YCkpw4GevuDwAPnM1jzGyru7fNUEl5S+9LanpfUtP7klqhvS/p/J14GFictL4o2JayjZlFgDoSJ2XTeayIiMygdIJ+C7DSzJaZWSmJk6sbJ7XZCNwWLN8IPOnuHmy/xczKzGwZsBL4ZWZKFxGRdEzZdRP0ud8JPEFieOWX3H2Hmd0DbHX3jcCDwFeDk609JL4MCNo9RuLEbRT44wyOuDmrrp4iovclNb0vqel9Sa2g3hdLHHiLiEih0lUTIiIFTkEvIlLg8jLozew6M9tjZu1mdle268kWM1tsZk+Z2U4z22FmfxZsrzezH5rZy8F/52a71tlmZmEze87MvhOsLzOzzcFn5tFgYEHRMbM5Zva4me02s11m9np9XsDM/jz4N7TdzL5uZuWF9JnJu6BPmpLhemANcGsw1UIxigIfc/c1wJXAHwfvxV3Aj9x9JfCjYL3Y/BmwK2n9XuA+d18B9JKYtqMYfRb4vrufD1xE4j0q6s+LmbUAfwq0uftaEoNOJqZyKYjPTN4FPUlTMrj7GDAxJUPRcfej7v6rYPkUiX+0LSTej4eCZg8B78lKgVliZouAdwJfDNYNuJrE9BxQhO8JgJnVAW8mMUoOdx9z95MU+eclEAEqguuAKoGjFNBnJh+DPtWUDK+ZVqHYmNlS4BJgM9Dk7keDXceApmzVlSWfAf4CmJiopQE46e4TN5ct1s/MMqAL+HLQrfVFM6uiyD8v7n4Y+D/AQRIB3wc8SwF9ZvIx6GUSM6sGvgH8V3fvT94XXLhWNGNozexdwHF3fzbbteSgCHAp8I/ufgkwyKRummL7vAAE5yQ2kPgibAaqgOuyWlSG5WPQa1qFJGZWQiLkv+bu3ww2d5rZwmD/QuB4turLgjcAN5jZfhLdeleT6JeeE/xZDsX7mekAOtx9c7D+OIngL+bPC8DbgH3u3uXu48A3SXyOCuYzk49Bn86UDEUh6Ht+ENjl7p9O2pU8JcVtwLdmu7ZscfdPuPsid19K4rPxpLt/CHiKxPQcUGTvyQR3PwYcMrPVwaZrSFy1XrSfl8BB4Eozqwz+TU28LwXzmcnLK2PN7B0k+mEnpmT42+xWlB1m9kbgaeBFft0f/Zck+ukfA1qBA8AH3L0nK0VmkZldBXzc3d9lZstJHOHXA88Bvx3cJ6GomNnFJE5SlwJ7gf9M4oCvqD8vZvbXwM0kRrI9B/w+iT75gvjM5GXQi4hI+vKx60ZERM6Cgl5EpMAp6EVECpyCXkSkwCnoRUQKnIJeRKTAKehFRArc/wejnlZsOUt23wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(num_atoms)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get number of hydrophilic and lipophilic molecules in logP dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = '../data/3_final_data/'\n",
    "\n",
    "SMILES_COLUMN = 'smiles'\n",
    "VALUE_COLUMN = 'logP'\n",
    "\n",
    "file = 'logp_wo_averaging'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(os.path.join(DATA_PATH, file+'.csv'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of hydrophilic molecules =  1523\n",
      "Number of lipophilic molecules =  12236\n"
     ]
    }
   ],
   "source": [
    "print('Number of hydrophilic molecules = ', \\\n",
    "      len(data[data[VALUE_COLUMN]<0]))\n",
    "print('Number of lipophilic molecules = ', \\\n",
    "      len(data[data[VALUE_COLUMN]>0]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LogP without logp.json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATASET_PATH = '../data/3_final_data/'\n",
    "SMILES_COLUMN = 'smiles'\n",
    "VALUE_COLUMN = 'logP'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = pd.read_csv(os.path.join(DATASET_PATH, 'logP_wo_logp_json.csv'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 13953 entries, 0 to 13952\n",
      "Data columns (total 2 columns):\n",
      " #   Column  Non-Null Count  Dtype  \n",
      "---  ------  --------------  -----  \n",
      " 0   smiles  13953 non-null  object \n",
      " 1   logP    13953 non-null  float64\n",
      "dtypes: float64(1), object(1)\n",
      "memory usage: 218.1+ KB\n"
     ]
    }
   ],
   "source": [
    "dataset.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_wo_averaging = dataset.groupby([SMILES_COLUMN]).agg(lambda x:x.value_counts().index[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 13688 entries, BrC(Br)(Br)Br to n1onc2c1NC1Nc3nonc3NC1N2\n",
      "Data columns (total 1 columns):\n",
      " #   Column  Non-Null Count  Dtype  \n",
      "---  ------  --------------  -----  \n",
      " 0   logP    13688 non-null  float64\n",
      "dtypes: float64(1)\n",
      "memory usage: 213.9+ KB\n"
     ]
    }
   ],
   "source": [
    "dataset_wo_averaging.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATASET_OTPUT_PATH = '../data/3_final_data/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_wo_averaging.to_csv(os.path.join(DATASET_OTPUT_PATH,'logp_wo_logp_json_wo_averaging.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split logp data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_test_validation_split(df):\n",
    "    from sklearn.model_selection import train_test_split\n",
    "    train_data, rest_data = train_test_split(df, test_size=0.3)\n",
    "    test_data, validation_data = train_test_split(rest_data, test_size=0.5)\n",
    "    return train_data.reset_index(drop=True), validation_data.reset_index(drop=True), test_data.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = '../data/3_final_data/'\n",
    "\n",
    "file = 'logp_wo_logp_json_wo_averaging'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logp_wo_logp_json_wo_averaging shape:  (13688, 2)\n",
      "SPLITTED SHAPES:\n",
      "\ttrain: (9581, 2)\n",
      "\tvalidation: (2054, 2)\n",
      "\ttest: (2053, 2)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv(os.path.join(DATA_PATH, file+'.csv'))\n",
    "\n",
    "\n",
    "print(file, 'shape: ', data.shape)    \n",
    "train, validation, test = train_test_validation_split(data)\n",
    "print('SPLITTED SHAPES:\\n\\ttrain: {0}\\n\\tvalidation: {1}\\n\\ttest: {2}\\n'.format(train.shape, validation.shape, test.shape))\n",
    "\n",
    "train.to_csv(DATA_PATH + 'split_data/' + file + '_train.csv')\n",
    "validation.to_csv(DATA_PATH + 'split_data/' + file + '_validation.csv')\n",
    "test.to_csv(DATA_PATH + 'split_data/' + file + '_test.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# logD wo pH dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = \"../data/3_final_data/\"\n",
    "DATASET_OUTPUT_PATH = '../data/3_final_data/'\n",
    "SMILES_COLUMN = 'smiles'\n",
    "VALUE_COLUMN = 'logD'\n",
    "PH_COLUMN = 'pH'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "logd_ph_data = pd.read_csv(os.path.join(DATA_PATH, 'logD_pH.csv'), index_col= 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>smiles</th>\n",
       "      <th>pH</th>\n",
       "      <th>logD</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Brc1c(-c2ccc3c(c2)OCO3)nc2ncccn12</td>\n",
       "      <td>7.4</td>\n",
       "      <td>3.48</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Brc1c(NC2=NCCN2)ccc2nccnc12</td>\n",
       "      <td>7.4</td>\n",
       "      <td>0.31</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Brc1c[nH]c(=NCc2ccccc2)nc1N=c1cc(C2CC2)[nH][nH]1</td>\n",
       "      <td>7.4</td>\n",
       "      <td>4.11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Brc1cc(Br)c(NC2=NCCN2)c(Br)c1</td>\n",
       "      <td>7.4</td>\n",
       "      <td>2.51</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Brc1cc(Br)cc(COC[C@H](c2ccccc2)N2CCNCC2)c1</td>\n",
       "      <td>7.4</td>\n",
       "      <td>2.80</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                             smiles   pH  logD\n",
       "0                 Brc1c(-c2ccc3c(c2)OCO3)nc2ncccn12  7.4  3.48\n",
       "1                       Brc1c(NC2=NCCN2)ccc2nccnc12  7.4  0.31\n",
       "2  Brc1c[nH]c(=NCc2ccccc2)nc1N=c1cc(C2CC2)[nH][nH]1  7.4  4.11\n",
       "3                     Brc1cc(Br)c(NC2=NCCN2)c(Br)c1  7.4  2.51\n",
       "4        Brc1cc(Br)cc(COC[C@H](c2ccccc2)N2CCNCC2)c1  7.4  2.80"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logd_ph_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "logd_data = logd_ph_data.drop(PH_COLUMN, axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 5584 entries, 0 to 5583\n",
      "Data columns (total 2 columns):\n",
      " #   Column  Non-Null Count  Dtype  \n",
      "---  ------  --------------  -----  \n",
      " 0   smiles  5584 non-null   object \n",
      " 1   logD    5584 non-null   float64\n",
      "dtypes: float64(1), object(1)\n",
      "memory usage: 130.9+ KB\n"
     ]
    }
   ],
   "source": [
    "logd_data.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "logd_data = logd_data.drop_duplicates()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 5578 entries, 0 to 5583\n",
      "Data columns (total 2 columns):\n",
      " #   Column  Non-Null Count  Dtype  \n",
      "---  ------  --------------  -----  \n",
      " 0   smiles  5578 non-null   object \n",
      " 1   logD    5578 non-null   float64\n",
      "dtypes: float64(1), object(1)\n",
      "memory usage: 130.7+ KB\n"
     ]
    }
   ],
   "source": [
    "logd_data.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "logd_wo_averaging = logd_data.groupby([SMILES_COLUMN]).agg(lambda x:x.value_counts().index[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 5515 entries, Brc1c(-c2ccc3c(c2)OCO3)nc2ncccn12 to c1nc(N2CCCCC2)c2[nH]cnc2n1\n",
      "Data columns (total 1 columns):\n",
      " #   Column  Non-Null Count  Dtype  \n",
      "---  ------  --------------  -----  \n",
      " 0   logD    5515 non-null   float64\n",
      "dtypes: float64(1)\n",
      "memory usage: 86.2+ KB\n"
     ]
    }
   ],
   "source": [
    "logd_wo_averaging.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='logD'>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(logd_wo_averaging[VALUE_COLUMN])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "logD\n",
       "(-10, -6]       0\n",
       "(-6, -4]        3\n",
       "(-4, -2]       92\n",
       "(-2, 0]       623\n",
       "(0, 2]       1811\n",
       "(2, 4]       2712\n",
       "(4, 6]        261\n",
       "(6, 8]         13\n",
       "(8, 10]         0\n",
       "Name: logD, dtype: int64"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ranges = [-10,-6, -4, -2, 0, 2, 4, 6, 8, 10]\n",
    "logd_wo_averaging[VALUE_COLUMN].groupby(pd.cut(logd_wo_averaging[VALUE_COLUMN], ranges)).count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "logd_wo_averaging.to_csv(os.path.join(DATASET_OUTPUT_PATH,'logd_wo_averaging.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LogD_only_Lipophilicity dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = \"../data/2_standardize/logd\"\n",
    "DATASET_OUTPUT_PATH = '../data/3_final_data/'\n",
    "SMILES_COLUMN = 'smiles'\n",
    "VALUE_COLUMN = 'logD'\n",
    "PH_COLUMN = 'pH'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "logd_lip_data = pd.read_csv(os.path.join(DATA_PATH, 'normal_logd_lipophilicity_dataset.csv'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "logd_data = logd_lip_data.drop(PH_COLUMN, axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 4198 entries, 0 to 4197\n",
      "Data columns (total 2 columns):\n",
      " #   Column  Non-Null Count  Dtype  \n",
      "---  ------  --------------  -----  \n",
      " 0   logD    4198 non-null   float64\n",
      " 1   smiles  4198 non-null   object \n",
      "dtypes: float64(1), object(1)\n",
      "memory usage: 65.7+ KB\n"
     ]
    }
   ],
   "source": [
    "logd_data.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "logd_data = logd_data.drop_duplicates()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 4194 entries, 0 to 4197\n",
      "Data columns (total 2 columns):\n",
      " #   Column  Non-Null Count  Dtype  \n",
      "---  ------  --------------  -----  \n",
      " 0   logD    4194 non-null   float64\n",
      " 1   smiles  4194 non-null   object \n",
      "dtypes: float64(1), object(1)\n",
      "memory usage: 98.3+ KB\n"
     ]
    }
   ],
   "source": [
    "logd_data.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "logd_wo_averaging = logd_data.groupby([SMILES_COLUMN]).agg(lambda x:x.value_counts().index[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 4166 entries, Brc1c[nH]c(=NCc2ccccc2)nc1N=c1cc(C2CC2)[nH][nH]1 to c1nc(N2CCCCC2)c2[nH]cnc2n1\n",
      "Data columns (total 1 columns):\n",
      " #   Column  Non-Null Count  Dtype  \n",
      "---  ------  --------------  -----  \n",
      " 0   logD    4166 non-null   float64\n",
      "dtypes: float64(1)\n",
      "memory usage: 65.1+ KB\n"
     ]
    }
   ],
   "source": [
    "logd_wo_averaging.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "logd_wo_averaging.to_csv(os.path.join(DATASET_OUTPUT_PATH,'logd_Lip_wo_averaging.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## logD data split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_test_validation_split(df):\n",
    "    from sklearn.model_selection import train_test_split\n",
    "    train_data, rest_data = train_test_split(df, test_size=0.3)\n",
    "    test_data, validation_data = train_test_split(rest_data, test_size=0.5)\n",
    "    return train_data.reset_index(drop=True), validation_data.reset_index(drop=True), test_data.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = '../data/3_final_data/'\n",
    "\n",
    "file = 'logd_wo_averaging'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logd_wo_averaging shape:  (5515, 2)\n",
      "SPLITTED SHAPES:\n",
      "\ttrain: (3860, 2)\n",
      "\tvalidation: (828, 2)\n",
      "\ttest: (827, 2)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv(os.path.join(DATA_PATH, file+'.csv'))\n",
    "\n",
    "\n",
    "print(file, 'shape: ', data.shape)    \n",
    "train, validation, test = train_test_validation_split(data)\n",
    "print('SPLITTED SHAPES:\\n\\ttrain: {0}\\n\\tvalidation: {1}\\n\\ttest: {2}\\n'.format(train.shape, validation.shape, test.shape))\n",
    "\n",
    "train.to_csv(DATA_PATH + 'split_data/' + file + '_train.csv')\n",
    "validation.to_csv(DATA_PATH + 'split_data/' + file + '_validation.csv')\n",
    "test.to_csv(DATA_PATH + 'split_data/' + file + '_test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of hydrophilic molecules =  715\n",
      "Number of lipophilic molecules =  4797\n"
     ]
    }
   ],
   "source": [
    "print('Number of hydrophilic molecules = ', \\\n",
    "      len(logd_wo_averaging[logd_wo_averaging[VALUE_COLUMN]<0]), round(len(logd_wo_averaging[logd_wo_averaging[VALUE_COLUMN]<0])))\n",
    "print('Number of lipophilic molecules = ', \\\n",
    "      len(logd_wo_averaging[logd_wo_averaging[VALUE_COLUMN]>0]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = '../data/3_final_data/'\n",
    "\n",
    "file = 'logd_Lip_wo_averaging'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logd_Lip_wo_averaging shape:  (4166, 2)\n",
      "SPLITTED SHAPES:\n",
      "\ttrain: (2916, 2)\n",
      "\tvalidation: (625, 2)\n",
      "\ttest: (625, 2)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv(os.path.join(DATA_PATH, file+'.csv'))\n",
    "\n",
    "\n",
    "print(file, 'shape: ', data.shape)    \n",
    "train, validation, test = train_test_validation_split(data)\n",
    "print('SPLITTED SHAPES:\\n\\ttrain: {0}\\n\\tvalidation: {1}\\n\\ttest: {2}\\n'.format(train.shape, validation.shape, test.shape))\n",
    "\n",
    "train.to_csv(DATA_PATH + 'split_data/' + file + '_train.csv')\n",
    "validation.to_csv(DATA_PATH + 'split_data/' + file + '_validation.csv')\n",
    "test.to_csv(DATA_PATH + 'split_data/' + file + '_test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}