file_read_write_performance_comparisson.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Checking the performance for READ and WRITE operations\n",
    "### methods: pandas.read_table + pandas.to_csv VS file.readlines() + file.write()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Using sklearn to create the dataset easily.\n",
    "    Make_classification allows to choose\n",
    "    the quantity of features and samples\n",
    "\"\"\"\n",
    "from sklearn.datasets import make_classification\n",
    "import time\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "\n",
    "def read_and_remove_first_lines_dataframe(file_path, lines_to_remove):\n",
    "    df = pd.read_table(file_path, sep='\\t', header=0)\n",
    "    df[lines_to_remove:].to_csv(file_path+\"removing_lines.txt\", header=True, index=None, sep='\\t', mode='w')\n",
    "\n",
    "def read_and_remove_first_lines_readlines(file_path, lines_to_remove):\n",
    "    line_counter = 0\n",
    "    with open(file_path, \"r\") as f:\n",
    "        lines = f.readlines()\n",
    "    with open(file_path+\"removing_lines.txt\", \"w\") as f:\n",
    "        for line in lines:\n",
    "            if line_counter == 0 or line_counter > lines_to_remove:\n",
    "                f.write(line)\n",
    "            line_counter = line_counter + 1\n",
    "\n",
    "#creates the dataset, converts to dataFrame and saves to file\n",
    "def create_dataset(samples, features, output_file):\n",
    "    dataset,_ = make_classification(n_samples=samples,n_features=features, n_redundant=0, n_informative=features)\n",
    "    dataset = pd.DataFrame(dataset)\n",
    "    dataset.to_csv(output_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "create_dataset(samples=100,features=10, output_file=\"C:/temp/dataset_small.txt\")\n",
    "create_dataset(samples=1000,features=100, output_file=\"C:/temp/dataset_medium.txt\")\n",
    "create_dataset(samples=10000,features=500, output_file=\"C:/temp/dataset_large.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculating time for READING operation only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 1min 54s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "performance = list()\n",
    "performance.append([\"method\", \"size\", \"duration\"])\n",
    "runs = 100\n",
    "\n",
    "start = time.time()\n",
    "file_path = f\"C:/temp/dataset_small.txt\"\n",
    "for i in range(runs):\n",
    "    df = pd.read_table(file_path, sep='\\t', header=0)\n",
    "end = time.time()\n",
    "total_time = end - start\n",
    "performance.append([\"dataframe\", \"small\", total_time])\n",
    "\n",
    "start = time.time()\n",
    "file_path = f\"C:/temp/dataset_small.txt\"\n",
    "for i in range(runs):\n",
    "    with open(file_path, \"r\") as f:\n",
    "        lines = f.readlines()\n",
    "end = time.time()\n",
    "total_time = end - start\n",
    "performance.append([\"readlines\", \"small\", total_time])\n",
    "\n",
    "start = time.time()\n",
    "file_path = f\"C:/temp/dataset_medium.txt\"\n",
    "for i in range(runs):\n",
    "    df = pd.read_table(file_path, sep='\\t', header=0)\n",
    "end = time.time()\n",
    "total_time = end - start\n",
    "performance.append([\"dataframe\", \"medium\", total_time])\n",
    "\n",
    "start = time.time()\n",
    "file_path = f\"C:/temp/dataset_medium.txt\"\n",
    "for i in range(runs):\n",
    "    with open(file_path, \"r\") as f:\n",
    "        lines = f.readlines()\n",
    "end = time.time()\n",
    "total_time = end - start\n",
    "performance.append([\"readlines\", \"medium\", total_time])\n",
    "\n",
    "start = time.time()\n",
    "file_path = f\"C:/temp/dataset_large.txt\"\n",
    "for i in range(runs):\n",
    "    df = pd.read_table(file_path, sep='\\t', header=0)\n",
    "end = time.time()\n",
    "total_time = end - start\n",
    "performance.append([\"dataframe\", \"large\", total_time])\n",
    "\n",
    "start = time.time()\n",
    "file_path = f\"C:/temp/dataset_large.txt\"\n",
    "for i in range(runs):\n",
    "    with open(file_path, \"r\") as f:\n",
    "        lines = f.readlines()\n",
    "end = time.time()\n",
    "total_time = end - start\n",
    "performance.append([\"readlines\", \"large\", total_time])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Converting all the data from the list to a dataframe"
   ]
  },
  {
   "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>method</th>\n",
       "      <th>size</th>\n",
       "      <th>duration</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>dataframe</td>\n",
       "      <td>small</td>\n",
       "      <td>0.104042</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>readlines</td>\n",
       "      <td>small</td>\n",
       "      <td>0.015023</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>dataframe</td>\n",
       "      <td>medium</td>\n",
       "      <td>1.869882</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>readlines</td>\n",
       "      <td>medium</td>\n",
       "      <td>0.660270</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>dataframe</td>\n",
       "      <td>large</td>\n",
       "      <td>77.367451</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>readlines</td>\n",
       "      <td>large</td>\n",
       "      <td>34.196990</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      method    size   duration\n",
       "0  dataframe   small   0.104042\n",
       "1  readlines   small   0.015023\n",
       "2  dataframe  medium   1.869882\n",
       "3  readlines  medium   0.660270\n",
       "4  dataframe   large  77.367451\n",
       "5  readlines   large  34.196990"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performance_df = pd.DataFrame(performance[1:], columns=performance[0])\n",
    "performance_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### getting sqrt and log of duration to improve the plot visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>method</th>\n",
       "      <th>size</th>\n",
       "      <th>duration</th>\n",
       "      <th>duration_sqrt</th>\n",
       "      <th>duration_log2</th>\n",
       "      <th>duration_log10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>dataframe</td>\n",
       "      <td>small</td>\n",
       "      <td>0.104042</td>\n",
       "      <td>0.322555</td>\n",
       "      <td>-3.264768</td>\n",
       "      <td>-0.982793</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>readlines</td>\n",
       "      <td>small</td>\n",
       "      <td>0.015023</td>\n",
       "      <td>0.122567</td>\n",
       "      <td>-6.056707</td>\n",
       "      <td>-1.823250</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>dataframe</td>\n",
       "      <td>medium</td>\n",
       "      <td>1.869882</td>\n",
       "      <td>1.367436</td>\n",
       "      <td>0.902947</td>\n",
       "      <td>0.271814</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>readlines</td>\n",
       "      <td>medium</td>\n",
       "      <td>0.660270</td>\n",
       "      <td>0.812570</td>\n",
       "      <td>-0.598871</td>\n",
       "      <td>-0.180278</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>dataframe</td>\n",
       "      <td>large</td>\n",
       "      <td>77.367451</td>\n",
       "      <td>8.795877</td>\n",
       "      <td>6.273655</td>\n",
       "      <td>1.888558</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>readlines</td>\n",
       "      <td>large</td>\n",
       "      <td>34.196990</td>\n",
       "      <td>5.847819</td>\n",
       "      <td>5.095797</td>\n",
       "      <td>1.533988</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      method    size   duration  duration_sqrt  duration_log2  duration_log10\n",
       "0  dataframe   small   0.104042       0.322555      -3.264768       -0.982793\n",
       "1  readlines   small   0.015023       0.122567      -6.056707       -1.823250\n",
       "2  dataframe  medium   1.869882       1.367436       0.902947        0.271814\n",
       "3  readlines  medium   0.660270       0.812570      -0.598871       -0.180278\n",
       "4  dataframe   large  77.367451       8.795877       6.273655        1.888558\n",
       "5  readlines   large  34.196990       5.847819       5.095797        1.533988"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performance_df[\"duration_sqrt\"] = np.sqrt(performance_df[\"duration\"])\n",
    "performance_df[\"duration_log2\"] = np.log2(performance_df[\"duration\"])\n",
    "performance_df[\"duration_log10\"] = np.log10(performance_df[\"duration\"])\n",
    "\n",
    "# #replacing -inf to NaN, only on columns with -inf (columns 4 and 5)\n",
    "# #then replacing NaN with ZERO\n",
    "# performance_df.iloc[:,4:] = performance_df.iloc[:,4:].mask(np.isinf(performance_df.iloc[:,4:]))\n",
    "# performance_df.iloc[:,4:] = performance_df.iloc[:,4:].fillna(0)\n",
    "# performance_df\n",
    "\n",
    "performance_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Best plot option is square root of time in sec\n",
    "#### for the other options the visualizations are not good."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "checking if variable runs still exists, to avoid error while plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    runs\n",
    "except NameError:\n",
    "    runs = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot using square root value of duration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, '100 runs duration in sec (sqrt)'),\n",
       " Text(0.5, 0, 'size of the dataset'),\n",
       " Text(0.5, 1.0, 'File read speed comparisson')]"
      ]
     },
     "execution_count": 7,
     "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": [
    "p = sns.barplot(x=\"size\", y=\"duration_sqrt\", hue=\"method\", data=performance_df)\n",
    "p.set(xlabel=\"size of the dataset\", ylabel=f\"{runs} runs duration in sec (sqrt)\", title=\"File read speed comparisson\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "checking the time difference between the methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There was a differecen of 6.926 times for small dataset\n",
      "There was a differecen of 2.832 times for medium dataset\n",
      "There was a differecen of 2.262 times for large dataset\n"
     ]
    }
   ],
   "source": [
    "sizes = ['small', 'medium', 'large']\n",
    "for size in sizes:\n",
    "    values = performance_df['duration'].loc[performance_df['size'] == size]\n",
    "    dif = round(max(values) / min(values),3)\n",
    "    print(f\"There was a differecen of {dif} times for {size} dataset\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other visualizations (not that good)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#original value of duration\n",
    "p = sns.barplot(x=\"size\", y=\"duration\", hue=\"method\", data=performance_df)\n",
    "p.set(xlabel=\"size of the dataset\", ylabel=f\"{runs} runs duration in sec\", title=\"File read speed comparisson\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#log2 value of duration\n",
    "p = sns.barplot(x=\"size\", y=\"duration_log2\", hue=\"method\", data=performance_df)\n",
    "p.set(xlabel=\"size of the dataset\", ylabel=f\"{runs} runs duration in sec (log2)\", title=\"File read speed comparisson\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#log10 value of duration\n",
    "p = sns.barplot(x=\"size\", y=\"duration_log10\", hue=\"method\", data=performance_df)\n",
    "p.set(xlabel=\"size of the dataset\", ylabel=f\"{runs} runs duration in sec (log10)\", title=\"File read speed comparisson\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Now calculating time for READING and SAVING\n",
    "### The script also removes 4 lines of the text files to simulate any manipulation\n",
    "\n",
    "###### Time or line removal is trivial and not considered for this example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 5min 29s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "performance = list()\n",
    "performance.append([\"method\", \"size\", \"duration\"])\n",
    "runs = 100\n",
    "lines_to_remove = 4\n",
    "\n",
    "start = time.time()\n",
    "file_path = f\"C:/temp/dataset_small.txt\"\n",
    "for i in range(runs):\n",
    "    read_and_remove_first_lines_dataframe(file_path, lines_to_remove)\n",
    "end = time.time()\n",
    "total_time = end - start\n",
    "performance.append([\"dataframe\", \"small\", total_time])\n",
    "\n",
    "start = time.time()\n",
    "file_path = f\"C:/temp/dataset_small.txt\"\n",
    "for i in range(runs):\n",
    "    read_and_remove_first_lines_readlines(file_path, lines_to_remove)\n",
    "end = time.time()\n",
    "total_time = end - start\n",
    "performance.append([\"readlines\", \"small\", total_time])\n",
    "\n",
    "start = time.time()\n",
    "file_path = f\"C:/temp/dataset_medium.txt\"\n",
    "for i in range(runs):\n",
    "    read_and_remove_first_lines_dataframe(file_path, lines_to_remove)\n",
    "end = time.time()\n",
    "total_time = end - start\n",
    "performance.append([\"dataframe\", \"medium\", total_time])\n",
    "\n",
    "start = time.time()\n",
    "file_path = f\"C:/temp/dataset_medium.txt\"\n",
    "for i in range(runs):\n",
    "    read_and_remove_first_lines_readlines(file_path, lines_to_remove)\n",
    "end = time.time()\n",
    "total_time = end - start\n",
    "performance.append([\"readlines\", \"medium\", total_time])\n",
    "\n",
    "start = time.time()\n",
    "file_path = f\"C:/temp/dataset_large.txt\"\n",
    "for i in range(runs):\n",
    "    read_and_remove_first_lines_dataframe(file_path, lines_to_remove)\n",
    "end = time.time()\n",
    "total_time = end - start\n",
    "performance.append([\"dataframe\", \"large\", total_time])\n",
    "\n",
    "start = time.time()\n",
    "file_path = f\"C:/temp/dataset_large.txt\"\n",
    "for i in range(runs):\n",
    "    read_and_remove_first_lines_readlines(file_path, lines_to_remove)\n",
    "end = time.time()\n",
    "total_time = end - start\n",
    "performance.append([\"readlines\", \"large\", total_time])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There was a differecen of 3.978 times for small dataset\n",
      "There was a differecen of 2.532 times for medium dataset\n",
      "There was a differecen of 2.34 times for large dataset\n"
     ]
    },
    {
     "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": [
    "performance_df = pd.DataFrame(performance[1:], columns=performance[0])\n",
    "performance_df[\"duration_sqrt\"] = np.sqrt(performance_df[\"duration\"])\n",
    "\n",
    "#Square root value of duration\n",
    "p = sns.barplot(x=\"size\", y=\"duration_sqrt\", hue=\"method\", data=performance_df)\n",
    "p.set(xlabel=\"size of the dataset\", ylabel=f\"{runs} runs duration in sec (sqrt)\", title=\"File read speed comparisson\")\n",
    "\n",
    "sizes = ['small', 'medium', 'large']\n",
    "for size in sizes:\n",
    "    values = performance_df['duration'].loc[performance_df['size'] == size]\n",
    "    dif = round(max(values) / min(values),3)\n",
    "    print(f\"There was a differecen of {dif} times for {size} dataset\")"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}