src/batch_processing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch processing transaction data with pandas\n",
    "Dataset: https://www.kaggle.com/conorsully1/simulated-transactions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#imports\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import datetime\n",
    "\n",
    "path = \"/Users/conorosully/Google Drive/My Drive/Medium/Pandas Batch/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Gives an error\n",
    "df = pd.read_csv('../data/transactions.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['CUST_ID', 'START_DATE', 'END_DATE', 'TRANS_ID', 'DATE', 'YEAR',\n",
    "       'MONTH', 'DAY', 'EXP_TYPE', 'AMOUNT']\n",
    "\n",
    "#Load rows 1001 to 3000\n",
    "df = pd.read_csv('../data/transactions.csv',\n",
    "                 skiprows=1000,\n",
    "                 nrows=2000,\n",
    "                 names=names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_rows(steps,count,names,path='../Data/transactions.csv'):\n",
    "    \n",
    "    \"\"\"\n",
    "    Returns a subset of rows from a CSV. The fist [steps]*[count] \n",
    "    rows are skipped and the next [steps] rows are returned. \n",
    "    \n",
    "    params\n",
    "    ------------\n",
    "        steps: number of rows returned\n",
    "        count: count variable updated each iteration \n",
    "        names: columns names of dataset\n",
    "        path: location of csv\n",
    "    \"\"\"\n",
    "    \n",
    "    if count ==0:\n",
    "        df = pd.read_csv(path,\n",
    "                         nrows=steps)\n",
    "    else: \n",
    "        df = pd.read_csv(path,\n",
    "                         skiprows=steps*count,\n",
    "                         nrows=steps,\n",
    "                         names=names)\n",
    "    return df\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Total number of transactions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "261969720\n",
      "0:47:40.731500\n"
     ]
    }
   ],
   "source": [
    "begin = datetime.datetime.now()\n",
    "\n",
    "\n",
    "steps = 5000000\n",
    "names = ['CUST_ID', 'START_DATE', 'END_DATE', 'TRANS_ID', 'DATE', 'YEAR',\n",
    "       'MONTH', 'DAY', 'EXP_TYPE', 'AMOUNT']\n",
    "\n",
    "#Initialise number of transactions\n",
    "n = 0\n",
    "\n",
    "#Initialise count\n",
    "count = 0\n",
    "while True:\n",
    "    \n",
    "    #Return subsection of dataset\n",
    "    df = get_rows(steps,count,names)\n",
    "    \n",
    "    #Update number of transactions\n",
    "    n+=len(df)\n",
    "    \n",
    "    #Update count\n",
    "    count+=1\n",
    "    \n",
    "    #Exit loop\n",
    "    if len(df)!=steps:\n",
    "        break\n",
    "\n",
    "#Output number of rows\n",
    "print(n)  \n",
    "\n",
    "print(datetime.datetime.now() - begin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Total yearly expediture "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/conorosully/miniconda3/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3185: DtypeWarning: Columns (2) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  if (yield from self.run_code(code, result)):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 \n",
      "2010    2.041377e+08\n",
      "2011    5.842620e+08\n",
      "2012    9.596104e+08\n",
      "2013    1.324468e+09\n",
      "2014    1.699034e+09\n",
      "2015    2.058469e+09\n",
      "2016    2.399227e+09\n",
      "2017    2.709008e+09\n",
      "2018    2.997901e+09\n",
      "2019    3.267153e+09\n",
      "2020    3.163759e+09\n",
      "dtype: float64\n",
      "0:48:47.387897\n"
     ]
    }
   ],
   "source": [
    "begin = datetime.datetime.now()\n",
    "\n",
    "steps = 5000000\n",
    "names = ['CUST_ID', 'START_DATE', 'END_DATE', 'TRANS_ID', 'DATE', 'YEAR',\n",
    "       'MONTH', 'DAY', 'EXP_TYPE', 'AMOUNT']\n",
    "\n",
    "#Initialise yearly totals\n",
    "total_exp = pd.Series([0.0]*11, index=range(2010,2021))\n",
    "\n",
    "count = 0\n",
    "while True:\n",
    "    \n",
    "    df = get_rows(steps,count,names)\n",
    "\n",
    "    #Get yearly totals for subsection\n",
    "    exp = df.groupby(['YEAR'])['AMOUNT'].sum()\n",
    "    \n",
    "    #Loop over years 2010 to 2020\n",
    "    for year in range(2010,2021):\n",
    "        #Update yearly totals\n",
    "        total_exp[year] += exp[year]\n",
    "    \n",
    "    count+=1\n",
    "    print(count,end=\" \")\n",
    "    #Exit loop\n",
    "    if len(df)!=steps:\n",
    "        break\n",
    "print()\n",
    "print(total_exp)  \n",
    "\n",
    "print(datetime.datetime.now() - begin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot aggregation\n",
    "plt.figure(figsize=(10, 5))\n",
    "\n",
    "plt.plot(total_exp.index,total_exp/1000000000)\n",
    "plt.ylabel('Total expenditure ($ billion)',size=15)\n",
    "plt.xlabel('Year',size=15)\n",
    "plt.ylim(bottom=0)\n",
    "\n",
    "plt.savefig(path+\"agg_1.png\",dpi=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Average monthly entertainment expenditure in 2020"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 "
     ]
    }
   ],
   "source": [
    "begin = datetime.datetime.now()\n",
    "\n",
    "steps = 5000000\n",
    "names = ['CUST_ID', 'START_DATE', 'END_DATE', 'TRANS_ID', 'DATE', 'YEAR',\n",
    "       'MONTH', 'DAY', 'EXP_TYPE', 'AMOUNT']\n",
    "\n",
    "#Create empty total expenditure dataframe\n",
    "total_exp = pd.DataFrame(columns=['CUST_ID','MONTH','AMOUNT'])\n",
    "\n",
    "count = 0\n",
    "while True:\n",
    "    \n",
    "    df = get_rows(steps,count,names)\n",
    "\n",
    "    #Calculate monthly totals for each customer\n",
    "    df_2020 = df[(df.YEAR==2020) & (df.EXP_TYPE=='Entertainment')]\n",
    "    sum_exp = df_2020.groupby(['CUST_ID','MONTH'],as_index=False)['AMOUNT'].sum()\n",
    "    \n",
    "    #Append monthly totals\n",
    "    total_exp = total_exp.append(sum_exp)\n",
    "    \n",
    "    #Aggregate again so CUST_ID and MONTH are unique\n",
    "    total_exp = total_exp.groupby(['CUST_ID','MONTH'],as_index=False)['AMOUNT'].sum()\n",
    "    \n",
    "    count+=1\n",
    "    print(count,end=\" \")\n",
    "    #Exit loop\n",
    "    if len(df)!=steps:\n",
    "        break\n",
    "\n",
    "#Final aggregations\n",
    "avg_exp = sum_exp.groupby(['MONTH'])['AMOUNT'].mean()\n",
    "\n",
    "print()\n",
    "print(datetime.datetime.now() - begin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Plot aggregation\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(avg_exp.index,avg_exp)\n",
    "plt.ylabel('Average entertainment expenditure',size=12)\n",
    "plt.xlabel('Month',size=15)\n",
    "plt.ylim(bottom=0)\n",
    "\n",
    "plt.savefig(path+\"agg_2.png\",dpi=100)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}