ZipfModeling_syndt.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy.stats import norm\n",
    "import random\n",
    "import statistics as st\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "import scipy as sp\n",
    "from scipy import stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "novice_token =  pd.read_csv(r'C:\\xxxx\\novice_syn_data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "expert_token =  pd.read_csv(r'C:\\xxxx\\expert_syn_data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def logML(a):  \n",
    "    pro = -a*np.log(rank) - np.log(np.sum(1/rank**a))\n",
    "    \n",
    "\n",
    "    # Multiply the vector by frequencies\n",
    "    Lvector =pro * frequency\n",
    "\n",
    "    # LL is the sum\n",
    "    L = Lvector.sum()\n",
    "\n",
    "    # We want to maximize LogLikelihood or minimize (-1)*LogLikelihood\n",
    "    return(-L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zipflaw(dt):\n",
    "    zipf_dt = pd.DataFrame(columns=['Frequency'])\n",
    "    nov_freq = dt.drop(['Author'])\n",
    "    temp2=nov_freq[nov_freq!=0].sort_values(ascending=False).reset_index()\n",
    "    frequency = temp2[temp2.columns[1]]\n",
    "    probability = frequency/np.sum(frequency)\n",
    "    zipf_dt['Frequency'] = frequency\n",
    "    zipf_dt['Probability'] = probability\n",
    "    rank=np.array(range(1,len(temp2)+1))\n",
    "    zipf_dt['rank'] = rank\n",
    "    s_best = sp.optimize.minimize(logML, [1])\n",
    "    alpha=s_best.x\n",
    "    zipf_dt['alpha'] = alpha[0]\n",
    "    zipf_dt['zipflaw']=(rank**(-alpha))/np.sum(1/rank**alpha)\n",
    "    zipf_dt['log_pro'] = np.log(probability.astype(np.float64))\n",
    "    zipf_dt['log_rank'] = np.log(rank)\n",
    "    zipf_dt['log_zipflaw'] = -alpha*np.log(rank) - np.log(np.sum(1/rank**alpha))\n",
    "    return zipf_dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "expert_smp1 = pd.DataFrame(columns=['best_a','sample_size'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range (1,600):\n",
    "    dev_name= \"exp_dev\"+str(i)\n",
    "    expert = expert_token[expert_token['Author']==dev_name]\n",
    "    expert_dt = exp_smp.groupby('Author').sum().reset_index()\n",
    "    #dev=expert_dt.iloc[i]\n",
    "    dev = expert_dt.drop(['Author'],axis=1)\n",
    "    temp = dev.transpose()\n",
    "    exp_freq = temp[0]\n",
    "    temp2=exp_freq[exp_freq!=0].sort_values(ascending=False).reset_index()\n",
    "    frequency = temp2[temp2.columns[1]]\n",
    "    rank=np.array(range(1,len(temp2)+1))\n",
    "    s_best = sp.optimize.minimize(logML, [1])\n",
    "    alpha=s_best.x\n",
    "    expert_smp1=expert_smp1.append({'best_a':alpha[0],'sample_size':np.sum(exp_freq)},ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "novice_smp1 = pd.DataFrame(columns=['best_a','sample_size'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range (1,600):\n",
    "    dev_name= \"N_dev\"+str(i)\n",
    "    novice = novice_token[novice_token['Author']==dev_name]\n",
    "    novice_dt = nov_smp.groupby('Author').sum().reset_index()\n",
    "    #dev=expert_dt.iloc[i]\n",
    "    dev = novice_dt.drop(['Author'],axis=1)\n",
    "    temp = dev.transpose()\n",
    "    exp_freq = temp[0]\n",
    "    temp2=exp_freq[exp_freq!=0].sort_values(ascending=False).reset_index()\n",
    "    frequency = temp2[temp2.columns[1]]\n",
    "    rank=np.array(range(1,len(temp2)+1))\n",
    "    s_best = sp.optimize.minimize(logML, [1])\n",
    "    alpha=s_best.x\n",
    "    novice_smp1=novice_smp1.append({'best_a':alpha[0],'sample_size':np.sum(exp_freq)},ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "parm_exp=expert_smp1['best_a'].astype(float)\n",
    "sort_exp= sorted(np.array(parm_exp))\n",
    "exp_par_a = norm.pdf(sort_exp, np.mean(sort_exp), np.std(sort_exp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "parm_nov=novice_smp1['best_a'].astype(float)\n",
    "sort_nov= sorted(np.array(parm_nov))\n",
    "nov_par_a = norm.pdf(sort_nov, np.mean(sort_nov), np.std(sort_nov))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "m1=[np.mean(parm_exp),np.mean(parm_nov)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "st1=[np.std(parm_exp),np.std(parm_nov)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.95, 0.1, 'μ=0.966')"
      ]
     },
     "execution_count": 16,
     "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": [
    "fig, ax = plt.subplots(figsize=(6,4))\n",
    "#plt.ylabel(\"Probability\",fontsize=10)\n",
    "#plt.legend(('Probability Distribution','Original'),loc='upper right',\n",
    "           #ncol=3,\n",
    "           #fontsize=10)\n",
    "#plt.plot(sort_nov,nov_par_a,color='red')\n",
    "plt.hist(sort_nov,color='lightseagreen')\n",
    "#plt.plot(sort_exp,exp_par_a,color='blue')\n",
    "plt.hist(sort_exp, color='salmon')\n",
    "plt.xlabel(\"alpha\",fontsize=10)\n",
    "\n",
    "#plt.ylim(0,30)\n",
    "#plt.xlim(0.67,1.05)\n",
    "\n",
    "#plt.yticks(np.arange(-3, 3, 0.25))\n",
    "#plt.xticks(np.arange(0.67, 1.05, 0.03))\n",
    "\n",
    "plt.legend(('Novices','Experts'),loc='upper left',\n",
    "           ncol=1,\n",
    "           fontsize=8)\n",
    "plt.xlabel(\"alpha\",fontsize=10)\n",
    "#plt.xticks(fontsize=15)\n",
    "#plt.yticks(fontsize=15)\n",
    "#plt.savefig('alpha_dist_syn.png',dpi=700)\n",
    "plt.ylabel(\"Frequency\",fontsize=10)\n",
    "plt.axvline(x=0.746,linestyle='--',color='black')\n",
    "plt.text(0.68,0.1, 'μ={:.3f}'.format(0.746), va='center', ha=\"left\", bbox=dict(facecolor=\"w\",alpha=0.5),\n",
    "        transform=ax.get_xaxis_transform())\n",
    "plt.axvline(x=0.966,linestyle='--',color='black')\n",
    "plt.text(0.95,0.1, 'μ={:.3f}'.format(0.966), va='center', ha=\"right\", bbox=dict(facecolor=\"w\",alpha=0.5),\n",
    "        transform=ax.get_xaxis_transform())\n",
    "#plt.savefig('alpha_dist_syn.png',dpi=700)\n",
    "#plt.title('The distribution of alpha parameter in \"Expert\"and \"Novice\" groups', fontsize=12)\n",
    "#plt.title('Expert Developer', fontsize=10)"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}