data preprocessing_full-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "71d38029",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import sklearn\n",
    "import joblib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0832312a",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv('D:\\\\Users\\\\flammmes\\\\Downloads\\\\Book1.csv')\n",
    "df['d']=df['d'].str.replace(',','')\n",
    "df['Rsob']=df['Rsob'].str.replace(',','')\n",
    "dfn = pd.read_csv('D:\\\\Users\\\\flammmes\\\\Downloads\\\\composition.csv')\n",
    "\n",
    "\n",
    "dd = df.d.astype('float')\n",
    "df.d = df.d.astype('float')\n",
    "df['Rsob']= df['Rsob'].astype('float')\n",
    "df['Rsob']= np.abs(df['Rsob'])\n",
    "x = df.iloc[:,1]/df.iloc[:,8]\n",
    "mu = 1000*(df.iloc[:,3]*x*x+df.iloc[:,4]*x+df.iloc[:,5])/(df.iloc[:,6]*x+1)\n",
    "df.insert(9,'μob',mu)\n",
    "df.insert(12,'Tr',dfn.Tres)\n",
    "\n",
    "df = df[df['μob']<=50] \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f20f9da5",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "##strat1\n",
    "#from sklearn.impute import SimpleImputer\n",
    "#imputer = SimpleImputer(strategy='median')\n",
    "#df = pd.DataFrame(imputer.fit_transform(df), columns=df.columns)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "##strat2\n",
    "#df.dropna(inplace=True)\n",
    "\n",
    "\n",
    "##strat3\n",
    "#from sklearn.impute import KNNImputer\n",
    "#imputer = KNNImputer(n_neighbors=5, weights=\"uniform\")\n",
    "#df = pd.DataFrame(imputer.fit_transform(df), columns=df.columns)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1c02a84c",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\flammmes\\AppData\\Local\\Temp/ipykernel_13832/794019730.py:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df['Rsob'][df['Rsob'].isnull().values] = forest_reg.predict(dat2)\n",
      "C:\\Users\\flammmes\\AppData\\Local\\Temp/ipykernel_13832/794019730.py:38: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df['STO'][df['STO'].isnull().values] = lin_reg.predict(dat2)\n",
      "C:\\Users\\flammmes\\AppData\\Local\\Temp/ipykernel_13832/794019730.py:56: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df['Tr'][df['Tr'].isnull().values] = forest_reg.predict(dat2)\n"
     ]
    }
   ],
   "source": [
    "##strat4\n",
    "#df.Rsob[df.Rsob==0] = np.nan\n",
    "df.μob = 1/np.power(df.μob,1/1.5)\n",
    "my_new = pd.DataFrame({\n",
    "    'Pb':df.Pb,'μob':df.μob ,'Rs':df.Rsob\n",
    "})\n",
    "bb = my_new[my_new['Rs'].isnull().values]\n",
    "aa = my_new[my_new['Rs'].notnull().values]\n",
    "dat = aa.iloc[:,0:2].to_numpy()\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler()\n",
    "dat =scaler.fit_transform(dat)\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "\n",
    "forest_reg = RandomForestRegressor(n_estimators=100)\n",
    "forest_reg.fit(dat, aa.Rs)\n",
    "\n",
    "dat2 =bb.iloc[:,0:2].to_numpy()\n",
    "dat2 =scaler.transform(dat2)\n",
    "df['Rsob'][df['Rsob'].isnull().values] = forest_reg.predict(dat2)\n",
    "df.μob = 1/np.power(df.μob,1.5)\n",
    "\n",
    "df.μob = np.log(df.μob)\n",
    "my_new = pd.DataFrame({\n",
    "    'μob':df.μob, 'STO':df.STO\n",
    "})\n",
    "bb = my_new[my_new['STO'].isnull().values]\n",
    "aa = my_new[my_new['STO'].notnull().values]\n",
    "dat = aa.μob.to_numpy().reshape(-1,1)\n",
    "scaler2 = StandardScaler()\n",
    "dat =scaler2.fit_transform(dat)\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "lin_reg = LinearRegression()\n",
    "lin_reg.fit(dat, aa.STO)\n",
    "dat2 = bb.μob.to_numpy().reshape(-1,1)\n",
    "dat2 =scaler2.transform(dat2)\n",
    "df['STO'][df['STO'].isnull().values] = lin_reg.predict(dat2)\n",
    "df.μob = np.exp(df.μob)\n",
    "\n",
    "\n",
    "my_new = pd.DataFrame({\n",
    "    'Pb':df.Pb,'Pmax':df.Pmax ,'Rs':df.Rsob,'Tr':df.Tr\n",
    "})\n",
    "bb = my_new[my_new['Tr'].isnull().values]\n",
    "aa = my_new[my_new['Tr'].notnull().values]\n",
    "dat = aa.iloc[:,0:3].to_numpy()\n",
    "scaler3 = StandardScaler()\n",
    "dat =scaler3.fit_transform(dat)\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "\n",
    "forest_reg = RandomForestRegressor(n_estimators=100)\n",
    "forest_reg.fit(dat, aa.Tr)\n",
    "dat2 =bb.iloc[:,0:3].to_numpy()\n",
    "dat2 =scaler3.transform(dat2)\n",
    "df['Tr'][df['Tr'].isnull().values] = forest_reg.predict(dat2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ef9c1843",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"μob_cat\"] = pd.cut(df[\"μob\"],\n",
    "                               bins=[0., 5, np.inf],\n",
    "                               labels=[1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3eff34e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import StratifiedShuffleSplit\n",
    "\n",
    "split = StratifiedShuffleSplit(n_splits=1, test_size=0.2,random_state=3)\n",
    "for train_index, test_index in split.split(df, df[\"μob_cat\"]):\n",
    "    strat_train_set = df.iloc[train_index]\n",
    "    strat_test_set = df.iloc[test_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c9329412",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\flammmes\\AppData\\Roaming\\Python\\Python310\\site-packages\\pandas\\core\\frame.py:4906: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  return super().drop(\n"
     ]
    }
   ],
   "source": [
    "for set_ in (strat_train_set, strat_test_set):\n",
    "    set_.drop(\"μob_cat\", axis=1, inplace=True)\n",
    "    #set_.drop(\"μob\", axis=1, inplace=True)\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0b705300",
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = strat_train_set.copy()\n",
    "df2 = strat_test_set.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b1899ba5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df1[\"μob_cat\"] = pd.cut(df1[\"μob\"],\n",
    "                               bins=[0., 5, np.inf],\n",
    "                               labels=[1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e3b7d4a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "split = StratifiedShuffleSplit(n_splits=1, test_size=0.2,random_state=3)\n",
    "for ti, tei in split.split(df1, df1[\"μob_cat\"]):\n",
    "    strat_tr_set = df1.iloc[ti]\n",
    "    strat_val_set = df1.iloc[tei]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4d345108",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\flammmes\\AppData\\Roaming\\Python\\Python310\\site-packages\\pandas\\core\\frame.py:4906: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  return super().drop(\n"
     ]
    }
   ],
   "source": [
    "for set_ in (strat_tr_set, strat_val_set):\n",
    "    set_.drop(\"μob_cat\", axis=1, inplace=True)\n",
    "    #set_.drop(\"μob\", axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f5450b08",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = strat_tr_set.copy()\n",
    "df_val = strat_val_set.copy()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "158c913f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_func(a):\n",
    "    \n",
    "    dflist = []\n",
    "    for i in range(len(a)):\n",
    "        \n",
    "        \n",
    "        correlations_select = pd.DataFrame({'P':P_i,'μ':mu_i,'Rsob':instance[10],'API':instance[11],'Tr':instance[12]})\n",
    "        pressure_bubble_point = correlations_select.iloc[0,0]*np.linspace(1,1,20)\n",
    "        visc_bubble_point = correlations_select.iloc[0,1]*np.linspace(1,1,20)\n",
    "        correlations_select.insert(0,\"Pb\",pressure_bubble_point)\n",
    "        correlations_select.insert(2,'μob',visc_bubble_point)\n",
    "        dflist.append(correlations_select)\n",
    "        \n",
    "    \n",
    "    totaldf = pd.concat(dflist)\n",
    "    totaldf.Pb = totaldf.Pb*145.038\n",
    "    totaldf.P = totaldf.P*145.038\n",
    "    totaldf.insert(2,'ΔP', totaldf.P-totaldf.Pb)\n",
    "    \n",
    "    totaldf.API = 141.5*1000/totaldf.API -131.5\n",
    "    totaldf.Rsob = totaldf.Rsob*5.614583333333333\n",
    "    #totaldf = totaldf[totaldf.μ != totaldf.μob]\n",
    "    #totaldf.drop('P',axis=1,inplace=True)\n",
    "    return totaldf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "073deb2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = gen_func(df2)\n",
    "train_data = gen_func(df_train)\n",
    "val_data = gen_func(df_val)\n",
    "\n",
    "#y = test_data[test_data.ΔP==0]\n",
    "#x =  val_data[val_data.ΔP==0]\n",
    "#train_data = pd.concat([train_data,y,x])\n",
    "all_data = gen_func(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "56731908",
   "metadata": {},
   "outputs": [],
   "source": [
    "for a in [test_data,train_data,val_data,all_data]:\n",
    "    a.μ = np.sqrt(np.log(a.μ/a.μob+0.0012))\n",
    "    a.ΔP = np.power(a.ΔP,0.5)\n",
    "    #a.ΔP = np.log(a.ΔP+1)\n",
    "    #a.insert(0,'x1',a.ΔP*np.power(a.P/a.Pb,0.2))\n",
    "    a.μob = a.ΔP*np.power(a.μob,0.07)\n",
    "\n",
    "    #a.insert(4,'logμob',a.μob*np.log(a.μob))\n",
    "    a.Pb = a.ΔP/np.log(a.Pb+400)\n",
    "    a.P = a.ΔP*np.power(a.P,-0.15)\n",
    "    a.API = a.ΔP/np.power(a.API,0.3)\n",
    "    a.Rsob = a.ΔP/np.log(a.Rsob+150)\n",
    "    #a.drop('μob',axis=1,inplace=True)\n",
    "    a.Tr = a.ΔP*np.power(a.Tr,-1.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "66e24cf2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "μ       1.000000\n",
       "μob     0.893792\n",
       "API     0.891319\n",
       "Rsob    0.886864\n",
       "Pb      0.881542\n",
       "Tr      0.879285\n",
       "P       0.877724\n",
       "ΔP      0.868429\n",
       "Name: μ, dtype: float64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "corr_matrix = all_data.corr()\n",
    "corr_matrix[\"μ\"].sort_values(ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5ed04e68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<AxesSubplot:title={'center':'Pb'}>,\n",
       "        <AxesSubplot:title={'center':'P'}>,\n",
       "        <AxesSubplot:title={'center':'ΔP'}>],\n",
       "       [<AxesSubplot:title={'center':'μob'}>,\n",
       "        <AxesSubplot:title={'center':'μ'}>,\n",
       "        <AxesSubplot:title={'center':'Rsob'}>],\n",
       "       [<AxesSubplot:title={'center':'API'}>,\n",
       "        <AxesSubplot:title={'center':'Tr'}>, <AxesSubplot:>]],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x648 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "all_data.hist(bins=100,figsize=(16,9))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4986712f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "\n",
    "X_train = train_data.drop([\"μ\"], axis=1) \n",
    "y_train = train_data[\"μ\"].copy()\n",
    "X_val = val_data.drop([\"μ\"], axis=1) \n",
    "y_val = val_data[\"μ\"].copy()\n",
    "X_test = test_data.drop([\"μ\"], axis=1) # drop labels for training set\n",
    "y_test = test_data[\"μ\"].copy()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9052894e",
   "metadata": {},
   "outputs": [],
   "source": [
    "poly_features = PolynomialFeatures(degree=2, include_bias=False)\n",
    "X_train_poly = poly_features.fit_transform(X_train)\n",
    "X_val_poly = poly_features.fit_transform(X_val)\n",
    "X_test_poly = poly_features.fit_transform(X_test)\n",
    "poly_scaler = StandardScaler()\n",
    "X_train_poly = poly_scaler.fit_transform(X_train_poly)\n",
    "X_val_poly = poly_scaler.transform(X_val_poly)\n",
    "X_test_poly = poly_scaler.transform(X_test_poly)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "eee84125",
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = StandardScaler()\n",
    "X_train= scaler.fit_transform(X_train)\n",
    "X_val= scaler.transform(X_val)\n",
    "X_test= scaler.transform(X_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e7f2c69a",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_features_full = [X_train,X_val,X_test]\n",
    "X_features_poly_full = [X_train_poly,X_val_poly,X_test_poly]\n",
    "y_labels_full = [y_train,y_val,y_test]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6173d002",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stored 'X_features_full' (list)\n",
      "Stored 'X_features_poly_full' (list)\n",
      "Stored 'y_labels_full' (list)\n"
     ]
    }
   ],
   "source": [
    "%store X_features_full\n",
    "%store X_features_poly_full\n",
    "%store y_labels_full\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "76220197",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stored 'totaldf_full' (DataFrame)\n",
      "Stored 'all_data_full' (DataFrame)\n"
     ]
    }
   ],
   "source": [
    "totaldf_full = gen_func(df2)\n",
    "%store totaldf_full\n",
    "totaldf_full\n",
    "all_data_full = gen_func(df)\n",
    "%store all_data_full"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4e202180",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4.73480618, 10.45996323, 36.05279401, 36.44620067,  5.59370402,\n",
       "       12.77004143,  0.09816896])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scaler.mean_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b6be452e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.29100268e+00, 2.05784009e+01, 2.81406809e+02, 3.15476005e+02,\n",
       "       7.68736219e+00, 3.86796612e+01, 2.05977533e-03])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scaler.var_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abcf3a6a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}