jrtechs-RandomScripts/notebooks/cuda-vs-cpu.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wed Jul  1 11:16:12 2020       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 440.82       Driver Version: 440.82       CUDA Version: 10.2     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  GeForce GTX 106...  Off  | 00000000:01:00.0  On |                  N/A |\n",
      "|  0%   49C    P2    26W / 120W |   2808MiB /  3016MiB |      2%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                       GPU Memory |\n",
      "|  GPU       PID   Type   Process name                             Usage      |\n",
      "|=============================================================================|\n",
      "|    0      1972      G   /usr/libexec/Xorg                             59MiB |\n",
      "|    0      2361      G   /usr/libexec/Xorg                            280MiB |\n",
      "|    0      2485      G   /usr/bin/gnome-shell                         231MiB |\n",
      "|    0      3214      G   ...uest-channel-token=15065411588967843042    23MiB |\n",
      "|    0      4090      G   /usr/lib64/firefox/firefox                    12MiB |\n",
      "|    0      4151      G   /usr/lib64/firefox/firefox                     2MiB |\n",
      "|    0      4194      G   /usr/lib64/firefox/firefox                     2MiB |\n",
      "|    0      4917      G   /usr/lib64/firefox/firefox                     2MiB |\n",
      "|    0      5777      G   /usr/lib64/firefox/firefox                     2MiB |\n",
      "|    0     33033      G   /usr/lib64/firefox/firefox                     4MiB |\n",
      "|    0     37575      G   /usr/lib64/firefox/firefox                   167MiB |\n",
      "|    0     37626      G   /usr/lib64/firefox/firefox                     2MiB |\n",
      "|    0     50906      G   ...quest-channel-token=3573384613177380021   121MiB |\n",
      "|    0     90844      C   /home/jeff/Documents/python/ml/bin/python   1881MiB |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "print(torch.cuda.is_available())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time # times in seconds\n",
    "def time_torch(size):\n",
    "    x = torch.rand(size, size, device=torch.device(\"cuda\"))\n",
    "    start = time.time()\n",
    "    x.sin_()\n",
    "    end = time.time()\n",
    "    return(end - start)\n",
    "\n",
    "def time_cpu(size):\n",
    "    x = torch.rand(size, size, device=torch.device(\"cpu\"))\n",
    "    start = time.time()\n",
    "    x.sin_()\n",
    "    end = time.time()\n",
    "    return(end - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([0.00028634071350097656, 1.049041748046875e-05, 4.291534423828125e-06, 4.0531158447265625e-06], [3.9577484130859375e-05, 1.0728836059570312e-05, 1.0013580322265625e-05, 1.0013580322265625e-05])\n"
     ]
    }
   ],
   "source": [
    "def get_cuda_cpu_times(sizes):\n",
    "    cpuTimes = []\n",
    "    cudaTimes = []\n",
    "\n",
    "    for s in sizes:\n",
    "        cpuTimes += [time_cpu(s)]\n",
    "        cudaTimes += [time_torch(s)]\n",
    "    return cpuTimes, cudaTimes\n",
    "\n",
    "print(get_cuda_cpu_times(range(2, 10, 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def plot_cuda_vs_cpu(cpuTimes, cudaTimes, sizes, xLab=\"Matrix Width\"):\n",
    "    plt.title(\"CUDA vs CPU\")\n",
    "    cpu_plot = plt.plot(sizes, cpuTimes, label=\"CPU\")\n",
    "    cuda_plot = plt.plot(sizes, cudaTimes, label=\"CUDA\")\n",
    "    plt.legend(bbox_to_anchor=(0.8, 0.98), loc='upper left', borderaxespad=0.)\n",
    "    # plt.legend(handles=[cpu_plot, cuda_plot])\n",
    "    plt.xlabel(xLab)\n",
    "    plt.ylabel('Execution Time (Seconds)')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sizes = range(1, 50, 1)\n",
    "cpu_t, cuda_t = get_cuda_cpu_times(sizes)\n",
    "plot_cuda_vs_cpu(cpu_t, cuda_t, sizes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sizes = range(1, 5000, 100)\n",
    "cpu_t, cuda_t = get_cuda_cpu_times(sizes)\n",
    "plot_cuda_vs_cpu(cpu_t, cuda_t, sizes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# cpu_plot = plt.plot(sizes, cpuTimes, label=\"CPU\")\n",
    "cuda_plot = plt.plot(sizes, cuda_t, label=\"CUDA\")\n",
    "plt.legend(bbox_to_anchor=(0.8, 0.98), loc='upper left', borderaxespad=0.)\n",
    "# plt.legend(handles=[cpu_plot, cuda_plot])\n",
    "plt.xlabel('Matrix Size')\n",
    "plt.ylabel('Execution Time (Seconds)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.00036406517028808594"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time # times in seconds\n",
    "def time_torch_copy(size):\n",
    "    x = torch.rand(size, size, device=torch.device(\"cpu\"))\n",
    "    start = time.time()\n",
    "    x = x.cuda()\n",
    "    x.sin_()\n",
    "    end = time.time()\n",
    "    return(end - start)\n",
    "time_torch_copy(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def get_cuda_cpu_times_with_copy(sizes):\n",
    "    cpuTimes = []\n",
    "    cudaTimes = []\n",
    "    for s in sizes:\n",
    "        cpuTimes += [time_cpu(s)]\n",
    "        cudaTimes += [time_torch_copy(s)]\n",
    "    return cpuTimes, cudaTimes\n",
    "\n",
    "sizes = range(1, 5000, 100)\n",
    "cpu_t, cuda_t = get_cuda_cpu_times_with_copy(sizes)\n",
    "plot_cuda_vs_cpu(cpu_t, cuda_t, sizes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import time # times in seconds\n",
    "def time_torch_copy_and_back(size):\n",
    "    x = torch.rand(size, size, device=torch.device(\"cpu\"))\n",
    "    start = time.time()\n",
    "    x = x.cuda()\n",
    "    x.sin_()\n",
    "    x = x.cpu()\n",
    "    end = time.time()\n",
    "    return(end - start)\n",
    "time_torch_copy(2)\n",
    "\n",
    "def get_cuda_cpu_times_with_copy(sizes):\n",
    "    cpuTimes = []\n",
    "    cudaTimes = []\n",
    "    for s in sizes:\n",
    "        cpuTimes += [time_cpu(s)]\n",
    "        cudaTimes += [time_torch_copy_and_back(s)]\n",
    "    return cpuTimes, cudaTimes\n",
    "\n",
    "sizes = range(1, 5000, 100)\n",
    "cpu_t, cuda_t = get_cuda_cpu_times_with_copy(sizes)\n",
    "plot_cuda_vs_cpu(cpu_t, cuda_t, sizes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "def time_torch_operation_repetition(size, iterations):\n",
    "    x = torch.rand(size, size, device=torch.device(\"cpu\"))\n",
    "    start = time.time()\n",
    "    x = x.cuda()\n",
    "    for _ in range(0, iterations):  \n",
    "        x.sin()\n",
    "    end = time.time()\n",
    "    return(end - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "def time_cpu_operation_repetition(size, iterations):\n",
    "    x = torch.rand(size, size, device=torch.device(\"cpu\"))\n",
    "    start = time.time()\n",
    "    for _ in range(0, iterations):  \n",
    "        x.sin()\n",
    "    end = time.time()\n",
    "    return(end - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_cuda_cpu_times_with_iterations(iterations):\n",
    "    cpuTimes = []\n",
    "    cudaTimes = []\n",
    "    for i in iterations:\n",
    "        cpuTimes += [time_cpu_operation_repetition(300, i)]\n",
    "        cudaTimes += [time_torch_operation_repetition(300, i)]\n",
    "    return cpuTimes, cudaTimes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "iterations = range(1, 500, 5)\n",
    "cpu_t, cuda_t = get_cuda_cpu_times_with_iterations(iterations)\n",
    "plot_cuda_vs_cpu(cpu_t, cuda_t, iterations, xLab=\"Number of Operations\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ml",
   "language": "python",
   "name": "ml"
  },
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}