direct_bandgap_linear_model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Regression Model\n",
    "The block of codes below utilize Linear Regression Model as implemented in Scikit-learn to predict eigen values \n",
    "of HSE06 quality using the elementwise-orbital contribution of the atoms to the corresponding eigenstates in \n",
    "PBE calculations.\n",
    "### Note:\n",
    "We will require two .tar.gz files for running this notebook namely, special_concatenations_compounds_atom_sum.tar.gz \n",
    "and atom_sum_compound_csv_files.tar.gz. These are explicitly present here on the GitHub. For backup,\n",
    "you could also access these tarballs from dropbox (dropbox/ML_eigenshift) or \n",
    "from the Hyperion cluster (/work/sutton-lab/ml_eigenshift/krr/concatenated/modified_pettifor)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing modules:\n",
    "We will require following modules for using the linear model. Don't forget to use eg. pip install numpy and so on\n",
    "to install the missing modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/santosh/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:35: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps,\n",
      "/home/santosh/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:597: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, copy_X=True, fit_path=True,\n",
      "/home/santosh/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:836: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, copy_X=True, fit_path=True,\n",
      "/home/santosh/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:862: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, positive=False):\n",
      "/home/santosh/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:1097: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  max_n_alphas=1000, n_jobs=None, eps=np.finfo(np.float).eps,\n",
      "/home/santosh/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:1344: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  max_n_alphas=1000, n_jobs=None, eps=np.finfo(np.float).eps,\n",
      "/home/santosh/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:1480: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, copy_X=True, positive=False):\n",
      "/home/santosh/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/randomized_l1.py:152: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  precompute=False, eps=np.finfo(np.float).eps,\n",
      "/home/santosh/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/randomized_l1.py:320: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, random_state=None,\n",
      "/home/santosh/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/randomized_l1.py:580: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=4 * np.finfo(np.float).eps, n_jobs=None,\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import scipy as sp\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "from pathlib import Path\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "import matplotlib as mpl\n",
    "import pylab as pl\n",
    "import ase\n",
    "from ase.io import read, write\n",
    "from sklearn.metrics import mean_squared_log_error, mean_absolute_error\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn import linear_model\n",
    "import tarfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Atom-based feature\n",
    "We define here atom-based feature namely modified pettifor scale (Glawe et al 2016 New J. Phys. 18 093011). This\n",
    "is based on similarity index and gives a measure of replaceability of an element in a compound so that the crystal\n",
    "symmetry remains unchanged. Although the scale is unique for each elements, we construct compositional based value\n",
    "to represent a compound."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mae(y_true, y_pred):\n",
    "    return np.mean(abs(y_true-y_pred))\n",
    "\n",
    "def root_mean_squared_error(y_true, y_pred):\n",
    "    return np.sqrt(np.mean((y_true-y_pred)**2))\n",
    "\n",
    "def string_number_separator(string):\n",
    "    import re\n",
    "    temp = re.compile(\"([a-zA-Z]+)([0-9]+)\")\n",
    "    res = temp.match(string).groups()\n",
    "    return res\n",
    "\n",
    "def list_of_atoms_and_numbers(string):\n",
    "    atoms=[]\n",
    "    atoms_number=[]\n",
    "    str1=''\n",
    "    while len(str1)<len(string):\n",
    "        string1=str(string)[len(str1):]\n",
    "        x,y=string_number_separator(string1)\n",
    "        str1=str1+str(x)+str(y)\n",
    "        atoms.append(str(x))\n",
    "        atoms_number.append(int(y))\n",
    "    return atoms, atoms_number\n",
    "\n",
    "def modified_pettifor(in_atom):\n",
    "\n",
    "    mod_scale = {\n",
    "                \"He\": 1,\n",
    "                \"Ne\": 2,\n",
    "                \"Ar\": 3,\n",
    "                \"Kr\": 4,\n",
    "                \"Xe\": 5,\n",
    "                \"Rn\": 6,\n",
    "                \"Fr\": 7,\n",
    "                \"Cs\": 8,\n",
    "                \"Rb\": 9,\n",
    "                \"K\": 10,\n",
    "                \"Na\": 11,\n",
    "                \"Li\": 12,\n",
    "                \"Ra\": 13,\n",
    "                \"Ba\": 14,\n",
    "                \"Sr\": 15,\n",
    "                \"Ca\": 16,\n",
    "                \"Eu\": 17,\n",
    "                \"Yb\": 18,\n",
    "                \"Lu\": 19,\n",
    "                \"Tm\": 20,\n",
    "                \"Y\": 21,\n",
    "                \"Er\": 22,\n",
    "                \"Ho\": 23,\n",
    "                \"Dy\": 24,\n",
    "                \"Tb\": 25,\n",
    "                \"Gd\": 26,\n",
    "                \"Sm\": 27,\n",
    "                \"Pm\": 28,\n",
    "                \"Nd\": 29,\n",
    "                \"Pr\": 30,\n",
    "                \"Ce\": 31,\n",
    "                \"La\": 32,\n",
    "                \"Ac\": 33,\n",
    "                \"Th\": 34,\n",
    "                \"Pa\": 35,\n",
    "                \"U\": 36,\n",
    "                \"Np\": 37,\n",
    "                \"Pu\": 38,\n",
    "                \"Am\": 39,\n",
    "                \"Cm\": 40,\n",
    "                \"Bk\": 41,\n",
    "                \"Cf\": 42,\n",
    "                \"Es\": 43,\n",
    "                \"Fm\": 44,\n",
    "                \"Md\": 45,\n",
    "                \"No\": 46,\n",
    "                \"Lr\": 47,\n",
    "                \"Sc\": 48,\n",
    "                \"Zr\": 49,\n",
    "                \"Hf\": 50,\n",
    "                \"Ti\": 51,\n",
    "                \"Ta\": 52,\n",
    "                \"Nb\": 53,\n",
    "                \"V\": 54,\n",
    "                \"Cr\": 55,\n",
    "                \"Mo\": 56,\n",
    "                \"W\": 57,\n",
    "                \"Re\": 58,\n",
    "                \"Tc\": 59,\n",
    "                \"Os\": 60,\n",
    "                \"Ru\": 61,\n",
    "                \"Ir\": 62,\n",
    "                \"Rh\": 63,\n",
    "                \"Pt\": 64,\n",
    "                \"Pd\": 65,\n",
    "                \"Au\": 66,\n",
    "                \"Ag\": 67,\n",
    "                \"Cu\": 68,\n",
    "                \"Ni\": 69,\n",
    "                \"Co\": 70,\n",
    "                \"Fe\": 71,\n",
    "                \"Mn\": 72,\n",
    "                \"Mg\": 73,\n",
    "                \"Zn\": 74,\n",
    "                \"Cd\": 75,\n",
    "                \"Hg\": 76,\n",
    "                \"Be\": 77,\n",
    "                \"Al\": 78,\n",
    "                \"Ga\": 79,\n",
    "                \"In\": 80,\n",
    "                \"Tl\": 81,\n",
    "                \"Pb\": 82,\n",
    "                \"Sn\": 83,\n",
    "                \"Ge\": 84,\n",
    "                \"Si\": 85,\n",
    "                \"B\": 86,\n",
    "                \"C\": 87,\n",
    "                \"N\": 88,\n",
    "                \"P\": 89,\n",
    "                \"As\": 90,\n",
    "                \"Sb\": 91,\n",
    "                \"Bi\": 92,\n",
    "                \"Po\": 93,\n",
    "                \"Te\": 94,\n",
    "                \"Se\": 95,\n",
    "                \"S\": 96,\n",
    "                \"O\": 97,\n",
    "                \"At\": 98,\n",
    "                \"I\": 99,\n",
    "                \"Br\": 100,\n",
    "                \"Cl\": 101,\n",
    "                \"F\": 102,\n",
    "                \"H\": 103\n",
    "            }\n",
    "\n",
    "    return mod_scale[in_atom]/float(max(mod_scale.values()))\n",
    "\n",
    "def compound_pettifor(compound):\n",
    "    cpd=compound.split('-')[0]\n",
    "    in_atom,num_atom=list_of_atoms_and_numbers(cpd)\n",
    "    if len(in_atom)==1:\n",
    "        norm_pettifor=modified_pettifor(in_atom[0])\n",
    "        return norm_pettifor\n",
    "    else:\n",
    "        norm_pettifor=0\n",
    "        for i in range (len(in_atom)):\n",
    "            tot=sum(num_atom)\n",
    "            norm_pettifor+=(num_atom[i]/tot)*modified_pettifor(in_atom[i])\n",
    "        return norm_pettifor\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are defining three functions below. Please also see the comments above each functions for more details. \n",
    "First couple of functions namely 'two_csv_train_test', and 'single_csv_train_test' prepare the numpy arrays\n",
    "necessary for training and testing the linear regression model. The last function named 'plot' is to get the\n",
    "scatter plots using the outputs of the first two functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Functions two_csv_train_test takes 2 arguments. First is the path of csv file used for training while the\n",
    "# second is the path of csv for testing. The default input columns are [1s,2s,.....,6p,PBE_EF]\n",
    "#It returns four numpy arrays in following order: 1. train_input 2. test_input 3. train_target 4. test_target. \n",
    "# Note these in order are the arguments for function plot\n",
    "\n",
    "def two_csv_train_test(path_csv_train,path_csv_test):\n",
    "    train_csv_to_df=pd.read_csv(path_csv_train) # eg. concat_dir+'Ca1O1.csv'\n",
    "    #train_csv_to_df['pet'] = [ compound_pettifor(compound) for compound in train_csv_to_df['compound'] ]\n",
    "    columns_input=['pet','ACT_PBE','PD_PBE','bg_PBE','bg_HSE'] \n",
    "    keep_cols=columns_input\n",
    "    train_data_inp=train_csv_to_df[keep_cols].to_numpy()[:, :-1]\n",
    "    train_input_feature=train_csv_to_df[keep_cols].to_numpy()[:, :-1]\n",
    "    train_target_feature=train_csv_to_df[keep_cols].to_numpy()[:, -1].reshape(-1, 1)\n",
    "    #print(train_input_feature)\n",
    "    #print(train_target_feature)\n",
    "    test_csv_to_df=pd.read_csv(path_csv_test) # eg. concat_dir+'Ca1O1.csv'\n",
    "    test_csv_to_df['pet'] = [ compound_pettifor(compound) for compound in test_csv_to_df['compound'] ]    \n",
    "    test_data_inp=test_csv_to_df[keep_cols].to_numpy()[:, :-1]\n",
    "    test_input_feature=test_csv_to_df[keep_cols].to_numpy()[:, :-1]\n",
    "    test_target_feature=test_csv_to_df[keep_cols].to_numpy()[:, -1].reshape(-1, 1)\n",
    "    print(np.shape(train_input_feature),np.shape(train_target_feature))\n",
    "    return train_input_feature,test_input_feature,train_target_feature,test_target_feature\n",
    "\n",
    "# Functions single_csv_train_test takes 2 arguments. First is the path of the csv file used for both training and \n",
    "# testing. Second is the compress fraction of how much data to use from original (Recommended: use 1 for single\n",
    "# system (0.3-0.6) for specific concatenations. Use 0.1 for whole concatenated dataset). Note default split is 80/20\n",
    "# . Make sure you adjust it inside the function to change it. It returns four numpy arrays in following order: \n",
    "# train_input, test_input, train_target, test_target. Note these in order are the arguments for function plot\n",
    "\n",
    "def single_csv_train_test(path_csv_file,compress_fraction): \n",
    "    split_frac=0.8\n",
    "    ag2o_csv_to_df=pd.read_csv(path_csv_file) #eg. all_files_dir+'Ag2O1.csv'\n",
    "    columns_input=['pet','ACT_PBE','PD_PBE','bg_PBE','bg_HSE']\n",
    "    keep_cols=columns_input\n",
    "    ag2o_input_feature=ag2o_csv_to_df[keep_cols].to_numpy()\n",
    "    random_indices=ag2o_input_feature[np.random.randint(ag2o_input_feature.shape[0], size=int(compress_fraction*ag2o_input_feature.shape[0])), :]\n",
    "    siz_x,siz_yy=np.shape(random_indices)\n",
    "    split=int(siz_x*split_frac)\n",
    "    array1= random_indices[:split,:] # indexing/selection of the 80%\n",
    "    array2 = random_indices[split:,:]\n",
    "    print(np.shape(array1),np.shape(array2))\n",
    "    return array1[:, :-1],array2[:, :-1],array1[:,-1].reshape(-1,1),array2[:,-1].reshape(-1,1)\n",
    "\n",
    "\n",
    "\n",
    "# As suggested above function plot is used for generating scatter plot it takes four numpy arrays in following order as\n",
    "# input: 1. train_input 2. test_input 3. train_target 4. test_target . It returns plot as plt, train_mae, and test_mae\n",
    "# We can save, display the plot obtained from here. do not forget to close the plot after calling it. eg. plt.close()\n",
    "\n",
    "def plot(x,p,y,q):\n",
    "    clf=linear_model.LinearRegression()\n",
    "    y2=clf.fit(x,y)\n",
    "    y_hat2=clf.predict(x)\n",
    "    q_hat2=clf.predict(p)\n",
    "    train_mae=mean_absolute_error(y,y_hat2)\n",
    "    test_mae=mean_absolute_error(q,q_hat2)\n",
    "    #print(train_mae,test_mae)\n",
    "    a=np.min(y)\n",
    "    b=np.max(y)\n",
    "    #print(a,b)\n",
    "    diag_array=np.linspace(a, b, num=1000)\n",
    "    aspect_ratio=(6,5)\n",
    "    left_margin=0.2 # Adjust it for your best results\n",
    "    fig= plt.figure(figsize=aspect_ratio)\n",
    "    mpl.rcParams['axes.linewidth']=1.5\n",
    "    #plt.ylim(band_min,band_max)\n",
    "    #plt.xlim(xmin,xmax)\n",
    "    plt.scatter(diag_array,diag_array,s=0.5,color='black',alpha=1.0)\n",
    "    plt.scatter(y,y_hat2,color='grey',s=40,marker='o',label='train')\n",
    "    plt.scatter(q,q_hat2,color='blue',s=40,marker='^',label='test')\n",
    "    plt.xlabel(\"HSE band gap(in eV)\",fontsize=16)\n",
    "    plt.ylabel(\"ML band gap (eV)\",fontsize=16)\n",
    "    plt.xticks(fontsize=14)\n",
    "    plt.yticks(fontsize=14)\n",
    "    plt.tick_params(labelbottom=True, labeltop=False, labelleft=True, labelright=False,\n",
    "                     bottom=True, top=True, left=True, right=True)\n",
    "    #plt.axhline(y=0.0,color='purple',linestyle='--',linewidth=1.5)\n",
    "    plt.subplots_adjust(left=left_margin)\n",
    "    plt.legend(fontsize='14',ncol=1, loc='lower right',frameon=False)\n",
    "\n",
    "    #plt.savefig('_train='+str(train_mae)+'_test'+str(test_mae)+'.pdf',dpi=80)\n",
    "    #plt.show()\n",
    "    return plt,train_mae,test_mae"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We here provide the location of the csv files. These csv files provide the information of mostly PBE calculations.\n",
    "It displays sum of elementwise-orbital contribution to eigen states along with the eigenvalues, shift of eigenvalue\n",
    "wrt the fermi level, corresponding eigen values and shift from HSE06 calculations and finally the shift between PBE and\n",
    "HSE06 eigenvalues at each eigenstates. The csv files corresponding to each compound are found in the folder \n",
    "atom_sum_compound_csv_files or its corresponding tarball. The folder special_concatenations_compounds_atom_sum or \n",
    "its corresponding tarball consists of the concatenation of various files mostly intuitive by their name.\n",
    "You can also look for dropbox or Hyperion cluster to access them as detailed in first block above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The block below utilizes functions defined above to show/save the plot. Don't forget to use plt.savefig(\"name.pdf\",dpi=80)\n",
    "to save the figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(13, 5) (4, 5)\n",
      "0.22698373228831267 0.5971314482330091\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''\n",
    "x,p,y,q=single_csv_train_test(all_files_dir+'Ag2O1.csv',1.0)\n",
    "plt,train_mae,test_mae=plot(x,p,y,q)\n",
    "print(train_mae,test_mae)\n",
    "#plt.savefig('linear_regression_Ag2O1.pdf',dpi=80)\n",
    "plt.show()\n",
    "plt.close()\n",
    "\n",
    "x,p,y,q=two_csv_train_test(concat_dir+'Ca1O1.csv',all_files_dir+'Ag2O1.csv')\n",
    "plt,train_mae,test_mae=plot(x,p,y,q)\n",
    "print(train_mae,test_mae)\n",
    "plt.show()\n",
    "plt.close()\n",
    "'''\n",
    "x,p,y,q=single_csv_train_test('properties.csv',0.2)\n",
    "plt,train_mae,test_mae=plot(x,p,y,q)\n",
    "print(train_mae,test_mae)\n",
    "plt.savefig('concat_ten_percent_linear.pdf',dpi=80)\n",
    "plt.show()\n",
    "plt.close()\n",
    "pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}