term.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot fig4\n",
    "from pandas import read_csv, DataFrame\n",
    "from plotly.graph_objects import Figure, Scatter\n",
    "df = read_csv('fig4.csv', index_col=0)\n",
    "fig = Figure()\n",
    "config = DataFrame(dict(\n",
    "    name = [\n",
    "        'Device 1 upload',\n",
    "        'Device 2 upload',\n",
    "        'Device 3 upload',\n",
    "        'Device 1 download',\n",
    "        'Device 2 download',\n",
    "        'Device 3 download',\n",
    "    ],\n",
    "    line = [\n",
    "        dict(color='#FF8330'),\n",
    "        dict(color='#412A14'),\n",
    "        dict(color='#0F60B2'),\n",
    "        dict(color='#FFD74F', dash='3px'),\n",
    "        dict(color='#9A9A8D', dash='3px'),\n",
    "        dict(color='#79CAE5', dash='3px'),\n",
    "    ],\n",
    "), index = ['ul0','ul1','ul2','dl0','dl1','dl2',])\n",
    "for i in config.index:\n",
    "    fig.add_trace(Scatter(x=df.index, y=df[i], name=config.loc[i,'name'], line=config.loc[i,'line']))\n",
    "fig.update_layout(dict(\n",
    "    title=dict(\n",
    "        text='Fig.4. Optimal time-slot allocation under different<br>computation capacities of device 1.',\n",
    "        font=dict(size=16),\n",
    "    ),\n",
    "    xaxis=dict(\n",
    "        title=dict(\n",
    "            text='Device 1 computation capacity(x 1e9 CPU cycle/s)',\n",
    "            font=dict(size=12),\n",
    "        ),\n",
    "    ),\n",
    "    yaxis=dict(\n",
    "        title=dict(\n",
    "            text='UL/DL time slot allocation of device 1, 2 and 3',\n",
    "            font=dict(size=12),\n",
    "        ),\n",
    "    ),\n",
    "    legend=dict(\n",
    "        yanchor='top',\n",
    "        y=0.99,\n",
    "        xanchor='right',\n",
    "        x=0.99,\n",
    "        font=dict(size=11)\n",
    "    ),\n",
    "    width=720,\n",
    "    height=480\n",
    "))\n",
    "# TODO: add axis and title name, and plot size\n",
    "fig.show()\n",
    "fig.write_image(file='fig4.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# output fig4 data\n",
    "from run import single_run as sr\n",
    "from warnings import filterwarnings\n",
    "from numpy import sum, array\n",
    "from numpy.random import uniform\n",
    "from pandas import DataFrame\n",
    "filterwarnings('ignore')\n",
    "ulstr = 'ul'\n",
    "dlstr = 'dl'\n",
    "df = DataFrame(dict(\n",
    "    ul0 = [[] for i in range(7)],\n",
    "    dl0 = [[] for i in range(7)],\n",
    "    ul1 = [[] for i in range(7)],\n",
    "    dl1 = [[] for i in range(7)],\n",
    "    ul2 = [[] for i in range(7)],\n",
    "    dl2 = [[] for i in range(7)],\n",
    "), index=[i/2 for i in range(2, 9)])\n",
    "for a in range(2, 9):\n",
    "    print(a)\n",
    "    d = a/2\n",
    "    for b in range(10):\n",
    "        cal = sr(size=3, add_param=dict(\n",
    "            omega=array([6e4 for i in range(3)]),\n",
    "            f_l=array([d*1e9, 2e9, 3e9])\n",
    "        ))\n",
    "        print(f'  {b}')\n",
    "        # print(f'{cal[ulstr]}')\n",
    "        for c in range(3):\n",
    "            # print(f'{cal[ulstr][c]}, {cal[dlstr][c]}, {df.loc[d, ulstr+str(c)]}')\n",
    "            df.loc[d, f'ul{c}'] = df.loc[d, f'ul{c}'] + [cal['ul'][c]]\n",
    "            df.loc[d, f'dl{c}'] = df.loc[d, f'dl{c}'] + [cal['dl'][c]]\n",
    "for i in df.index:\n",
    "    for j in df.columns:\n",
    "        df.loc[i, j] = average(df.loc[i, j])\n",
    "df.to_csv('fig4.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot fig3\n",
    "from pandas import read_csv, DataFrame\n",
    "from plotly.graph_objects import Figure, Scatter\n",
    "df = read_csv('fig3.csv', index_col=0)\n",
    "config = DataFrame(dict(\n",
    "    name = [\n",
    "        'N=10',\n",
    "        'N=20',\n",
    "        'N=30',\n",
    "        'N=40',\n",
    "    ],\n",
    "    line = [\n",
    "        dict(color='#FF6600'),\n",
    "        dict(color='#0099CC'),\n",
    "        dict(color='#FFCA18'),\n",
    "        dict(color='#246EB9'),\n",
    "    ],\n",
    "), index = ['n10','n20','n30','n40',])\n",
    "fig = Figure()\n",
    "for i in config.index:\n",
    "    fig.add_trace(Scatter(x=df.index, y=df[i], name=config.loc[i,'name'], line=config.loc[i,'line']))\n",
    "fig.update_layout(dict(\n",
    "    title=dict(\n",
    "        text='Fig.3. Maximum delay against the edge computation<br>capacity with different numbers of users.',\n",
    "        font=dict(size=16,),\n",
    "    ),\n",
    "    xaxis=dict(\n",
    "        title=dict(\n",
    "            text='Edge computation capacity(x 1e9 CPU cycle/s)',\n",
    "            font=dict(size=12),\n",
    "        ),\n",
    "    ),\n",
    "    yaxis=dict(\n",
    "        title=dict(\n",
    "            text='Max delay of all devices in system(s)',\n",
    "            font=dict(size=12),\n",
    "        ),\n",
    "    ),\n",
    "    width=720,\n",
    "    height=480\n",
    "))\n",
    "# TODO: add axis and title name, and plot size\n",
    "fig.show()\n",
    "fig.write_image(file='fig3.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot fig2\n",
    "from pandas import read_csv, DataFrame\n",
    "from plotly.graph_objects import Figure, Scatter\n",
    "df = read_csv('fig2.csv', index_col=0)\n",
    "config = DataFrame(dict(\n",
    "    name = [\n",
    "        'Partial Offloading',\n",
    "        'Local Processing',\n",
    "        'Edge Processing',\n",
    "    ],\n",
    "    line = [\n",
    "        dict(color='#FF6600'),\n",
    "        dict(color='#757563'),\n",
    "        dict(color='#4785C4'),\n",
    "    ],\n",
    "), index = ['partial','local','edge',])\n",
    "fig = Figure()\n",
    "for i in config.index:\n",
    "    fig.add_trace(Scatter(x=df.index, y=df[i], name=config.loc[i,'name'], line=config.loc[i,'line']))\n",
    "fig.update_layout(dict(\n",
    "    title=dict(\n",
    "        text='Fig.2. Maximum delay against the number of devices in three schemes.',\n",
    "        font=dict(size=16),\n",
    "    ),\n",
    "    xaxis=dict(\n",
    "        title=dict(\n",
    "            text='Number of devices',\n",
    "            font=dict(size=12),\n",
    "        ),\n",
    "    ),\n",
    "    yaxis=dict(\n",
    "        title=dict(\n",
    "            text='Max delay of all devices in system(s)',\n",
    "            font=dict(size=12),\n",
    "        ),\n",
    "    ),\n",
    "    legend=dict(\n",
    "        yanchor='top',\n",
    "        y=0.99,\n",
    "        xanchor='left',\n",
    "        x=0.01,\n",
    "        font=dict(size=11)\n",
    "    ),\n",
    "    width=720,\n",
    "    height=480\n",
    "))\n",
    "# TODO: add axis and title name, and plot size\n",
    "fig.show()\n",
    "fig.write_image(file='fig2.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# output fig3 data(run for 95-120 min)\n",
    "from run import multiple_run as mr\n",
    "from pandas import DataFrame\n",
    "df = DataFrame(data = dict(\n",
    "    n10 = [0 for i in range(10, 90, 10)],\n",
    "    n20 = [0 for i in range(10, 90, 10)],\n",
    "    n30 = [0 for i in range(10, 90, 10)],\n",
    "    n40 = [0 for i in range(10, 90, 10)],\n",
    "), index = [i for i in range(10, 90, 10)])\n",
    "for i in range(10, 50, 10):\n",
    "    for j in df.index:\n",
    "        col = 'n'+str(i)\n",
    "        cal = mr(run=10, size=i, f_e=j*1e9)['partial']\n",
    "        print(f'(n{i}, {j})')\n",
    "        # print(f'n{i}, {j*1e9}, {df.loc[j, col]}, {cal}')\n",
    "        df.loc[j, col] = cal\n",
    "df.to_csv('fig3.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# output fig2 data\n",
    "from run import single_run as sr\n",
    "import pandas as pd\n",
    "from numpy import average\n",
    "\n",
    "df = pd.DataFrame(data = dict(\n",
    "    edge = [[] for i in range(7)],\n",
    "    local = [[] for i in range(7)],\n",
    "    partial = [[] for i in range(7)],\n",
    "), \n",
    "    index=[10, 15, 20, 25, 30, 35, 40],\n",
    ")\n",
    "for a in range(10):\n",
    "    for i in df.index:\n",
    "        cal = sr(i)\n",
    "        for j in df.columns:\n",
    "            df.loc[i, j] = df.loc[i, j] + [cal[j]]\n",
    "\n",
    "for i in df.index:\n",
    "    for j in df.columns:\n",
    "        df.loc[i, j] = average(df.loc[i, j])\n",
    "\n",
    "df.to_csv('fig2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setup import, variables, and func\n",
    "import numpy\n",
    "import warnings\n",
    "from numpy import array, sum, max, ones, isnan\n",
    "from numpy.linalg import norm\n",
    "from numpy.random import exponential, uniform\n",
    "from math import pow, sqrt, log2\n",
    "\n",
    "numpy.set_printoptions(precision=4)\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "# channel unit conversion func\n",
    "dbm2watt = lambda d: 1e-3 * pow(10, d/10)\n",
    "\n",
    "# channel parameter\n",
    "N = 10 # N: number of mobile devices\n",
    "B = 1e7 # total bandwidth of the channel = 10MHz\n",
    "N0 = dbm2watt(-174) # power density of AWGN = -174dBm/Hz\n",
    "gain_mean = 500\n",
    "h = array([dbm2watt(i) for i in exponential(1/gain_mean, N)])\n",
    "p_ul = array([dbm2watt(24) for i in range(N)]) # uplink transmissino power for device\n",
    "p_dl = array([dbm2watt(46) for i in range(N)]) # downlink transmission power for BS\n",
    "\n",
    "# channel capacity\n",
    "r_ul = array([B * log2(1 + p_ul[i]*pow(h[i], 2)/N0/B) for i in range(N)])\n",
    "r_dl = array([B * log2(1 + p_dl[i]*pow(h[i], 2)/N0/B) for i in range(N)])\n",
    "\n",
    "# computation parameter\n",
    "omega = uniform(1e5, 5e5, N) # task size is uniform [0.1, 0.5] Mbits\n",
    "beta = 0.5 # compression ratio\n",
    "f_e = 15e9 # edge computation capacity = 15e9 cycles/s\n",
    "f_l = uniform(1e9, 4e9, N) # local computation capacity = uniform [1e9, 4e9] cycle/s\n",
    "C = 1000 # cpu cycle for a bit = 1000 cycles/bit\n",
    "v_e = f_e / C\n",
    "v_l = f_l / C\n",
    "\n",
    "# initialize multiplier(mu, eta_n, gamma)\n",
    "mu = 1\n",
    "eta = ones(N)\n",
    "gamma = 1\n",
    "\n",
    "# t(normalized duration of time slot), gradient update\n",
    "xplus = lambda x: 1 if 1<(x if x>0 else 0) else (x if x>0 else 0)\n",
    "t_ul_n = lambda n: xplus(\n",
    "    sqrt(eta[n]*omega[n]/mu/r_ul[n]) -\n",
    "    v_l[n] / r_ul[n] -\n",
    "    sqrt(gamma*pow(v_l[n], 2)/mu/v_e/r_ul[n]) -\n",
    "    sqrt(beta*pow(v_l[n], 2)/r_ul[n]/r_dl[n])\n",
    ")\n",
    "t_dl_n = lambda n: xplus(\n",
    "    sqrt(eta[n]*omega[n]*beta/mu/r_dl[n]) -\n",
    "    sqrt(beta*pow(v_l[n], 2)/r_ul[n]/r_dl[n]) - \n",
    "    sqrt(gamma*beta*pow(v_l[n], 2)/mu/r_dl[n]/v_e) -\n",
    "    beta*v_l[n]/r_dl[n]\n",
    ")\n",
    "t_e_n = lambda n: xplus(\n",
    "    sqrt(eta[n]*omega[n]/mu/r_dl[n]) -\n",
    "    sqrt(mu*pow(v_l[n], 2)/gamma/v_e/r_ul[n]) -\n",
    "    v_l[n]/v_e -\n",
    "    sqrt(mu*beta*pow(v_l[n], 2)/gamma/r_dl[n]/v_e)\n",
    ")\n",
    "t_ul = lambda : array([t_ul_n(i) for i in range(N)])\n",
    "t_dl = lambda : array([t_dl_n(i) for i in range(N)])\n",
    "t_e = lambda : array([t_e_n(i) for i in range(N)])\n",
    "delay = lambda ul, e, dl: omega/v_l*(1-1/(1 + v_l/ul/r_ul + v_l/e/v_e + beta*v_l/dl/r_dl))\n",
    "phi = lambda ul, e, dl: 0 if (sum(eta)<1) else max(delay(ul, e, dl))\n",
    "delta_mu = lambda ul, dl : sum(ul+dl) - 1\n",
    "delta_gamma = lambda e: sum(e) - 1\n",
    "delta_eta = lambda ul, e, dl: delay(ul, e, dl) - phi(ul, e, dl)\n",
    "step = lambda k: 0.1/sqrt(k)\n",
    "\n",
    "# iteration limit\n",
    "delta = 1e-6\n",
    "k = 1e5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# main process\n",
    "\n",
    "# number of device dependent parameters\n",
    "N=10\n",
    "p_ul = array([dbm2watt(24) for i in range(N)])\n",
    "p_dl = array([dbm2watt(46) for i in range(N)])\n",
    "\n",
    "# randomized parameter\n",
    "h = array([dbm2watt(i) for i in exponential(1/gain_mean, N)])\n",
    "r_ul = array([B * log2(1 + p_ul[i]*pow(h[i], 2)/N0/B) for i in range(N)])\n",
    "r_dl = array([B * log2(1 + p_dl[i]*pow(h[i], 2)/N0/B) for i in range(N)])\n",
    "omega = uniform(1e5, 5e5, N)\n",
    "f_l = uniform(1e9, 4e9, N)\n",
    "v_l = f_l / C\n",
    "\n",
    "# initialize multiplier(mu, eta_n, gamma)\n",
    "mu = 1\n",
    "eta = ones(N)\n",
    "gamma = 1\n",
    "\n",
    "# gradient update lambda func\n",
    "t_ul_n = lambda n: xplus(\n",
    "    sqrt(eta[n]*omega[n]/mu/r_ul[n]) -\n",
    "    v_l[n] / r_ul[n] -\n",
    "    sqrt(gamma*pow(v_l[n], 2)/mu/v_e/r_ul[n]) -\n",
    "    sqrt(beta*pow(v_l[n], 2)/r_ul[n]/r_dl[n])\n",
    ")\n",
    "t_dl_n = lambda n: xplus(\n",
    "    sqrt(eta[n]*omega[n]*beta/mu/r_dl[n]) -\n",
    "    sqrt(beta*pow(v_l[n], 2)/r_ul[n]/r_dl[n]) - \n",
    "    sqrt(gamma*beta*pow(v_l[n], 2)/mu/r_dl[n]/v_e) -\n",
    "    beta*v_l[n]/r_dl[n]\n",
    ")\n",
    "t_e_n = lambda n: xplus(\n",
    "    sqrt(eta[n]*omega[n]/mu/r_dl[n]) -\n",
    "    sqrt(mu*pow(v_l[n], 2)/gamma/v_e/r_ul[n]) -\n",
    "    v_l[n]/v_e -\n",
    "    sqrt(mu*beta*pow(v_l[n], 2)/gamma/r_dl[n]/v_e)\n",
    ")\n",
    "t_ul = lambda : array([t_ul_n(i) for i in range(N)])\n",
    "t_dl = lambda : array([t_dl_n(i) for i in range(N)])\n",
    "t_e = lambda : array([t_e_n(i) for i in range(N)])\n",
    "\n",
    "# gradient update loop\n",
    "for i in range(1, int(k)+1):\n",
    "    ul = t_ul()\n",
    "    dl = t_dl()\n",
    "    e = t_e()\n",
    "    mu_new = xplus(mu + step(i) * delta_mu(ul, dl))\n",
    "    gamma_new = xplus(gamma + step(i) * delta_gamma(e))\n",
    "    d_eta = delta_eta(ul, e, dl)\n",
    "    eta_new = array([xplus(eta[j] + step(i) * d_eta[j]) for j in range(N)])\n",
    "    if (norm(mu_new - mu) < delta and\n",
    "        norm(gamma_new - gamma) < delta and\n",
    "        norm(eta_new - eta) < delta\n",
    "    ):\n",
    "        break\n",
    "    mu = mu_new\n",
    "    gamma = gamma_new\n",
    "    eta = eta_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numpy.set_printoptions(precision=4, floatmode='fixed')\n",
    "\n",
    "# final delay time\n",
    "ul = t_ul()\n",
    "dl = t_dl()\n",
    "e = t_e()\n",
    "print(f'Tl:     {omega*C/f_l}')\n",
    "print(f'Tn:     {delay(ul, e, dl)}')\n",
    "print(f'te:     {array(e)}')\n",
    "lamb = (1/ul/r_ul + C/f_e + beta/dl/r_dl)/(C/f_l + 1/ul/r_ul + C/f_e + beta/dl/r_dl)\n",
    "lamb = array([1 if isnan(i) else i for i in lamb])\n",
    "delay_l = lamb*omega*C/f_l\n",
    "print(f'lambda: {lamb}')\n",
    "print(f'delay:  {delay_l}')\n",
    "print(f'partial max: {max(delay_l):.4f}')\n",
    "print(f'local max:   {max(omega*C/f_l):.4f}')\n",
    "print(f'edge max:    {(norm(omega/r_ul) * N + max(omega/v_e) + norm(omega/r_dl) * N):.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# main loop\n",
    "for i in range(1, int(k)+1):\n",
    "    ul = t_ul()\n",
    "    dl = t_dl()\n",
    "    e = t_e()\n",
    "    if(numpy.count_nonzero(e) > 0):\n",
    "        print(e)\n",
    "    mu_new = xplus(mu + step(i) * delta_mu(ul, dl))\n",
    "    gamma_new = xplus(gamma + step(i) * delta_gamma(e))\n",
    "    d_eta = delta_eta(ul, e, dl)\n",
    "    eta_new = array([xplus(eta[j] + step(i) * d_eta[j]) for j in range(N)])\n",
    "    if(norm(mu_new - mu) < delta and\n",
    "        norm(gamma_new - gamma) < delta and\n",
    "        norm(eta_new - eta) < delta\n",
    "    ):\n",
    "        print(f'smaller than delta')\n",
    "        break\n",
    "    mu = mu_new\n",
    "    gamma = gamma_new\n",
    "    eta = eta_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = lambda n : print(sqrt(eta[n]*omega[n]/mu/r_dl[n]), \n",
    "    sqrt(mu*pow(v_l[n], 2)/gamma/v_e/r_ul[n]),\n",
    "    v_l[n]/v_e,\n",
    "    sqrt(mu*beta*pow(v_l[n], 2)/gamma/r_dl[n]/v_e),\n",
    "    t_e_n(n),\n",
    "    gamma\n",
    ")\n",
    "i(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'{t_ul()},\\n{omega/v_l},\\n{delay(ul, e, dl)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lamb = (1/t_ul()/r_ul + C/f_e + beta/t_dl()/r_dl)/(C/f_l + 1/t_ul()/r_ul + C/f_e + beta/t_dl()/r_dl)\n",
    "lamb = array([1 if isnan(i) else i for i in lamb])\n",
    "delay_l = lamb*omega*C/f_l\n",
    "print(f'{lamb}\\n{delay_l}\\nmax: {max(delay_l):.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t_e()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lamb = numpy.zeros(10)\n",
    "delay_e_ul = (1-lamb)*omega/t_ul()/r_ul\n",
    "delay_e_e = (1-lamb)*omega*C/f_e\n",
    "delay_e_dl = beta*(1-lamb)*omega/t_dl()/r_dl\n",
    "\n",
    "print(f'{delay_l},\\n{delay_e_ul},\\n{delay_e_e},\\n{delay_e_dl}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.15 ('pcs')",
   "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.15 (default, Nov  9 2022, 10:44:37) [MSC v.1916 64 bit (AMD64)]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "e48fd0e44bdd49d3602366ce512e8438cfd1f48d68012bba7db49570275579a1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}