{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Tracking memory leaks / memory fragmentation\n", "\n", "This notebook is for finding out where fastai doesn't allocate GPU RAM efficiently. Feel free to add other sections. Currently it only does a basic training loop, with some unfreezing and inference.\n", "\n", "The detection comes from reading the output of [IPyExperimentsPytorch](https://github.com/stas00/ipyexperiments/) per-cell reports.\n", "\n", "In particular watch Delta Peak column which may indicate where more GPU RAM was allocated before freeing some, which may lead to smalish holes in allocated GPU RAM which can't be re-used and thus causing fragmentation and leading to less total available GPU RAM." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%reload_ext autoreload\n", "%autoreload 2\n", "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from fastai.vision import *" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", "import numpy as np\n", "from ipyexperiments import IPyExperimentsPytorch\n", "#! pip install ipyexperiments" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", "assert str(device) == 'cuda:0', f\"we want GPU, got {device}\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from IPython.display import Markdown, display\n", "def alert(string, color='red'):\n", " display(Markdown(f\"**{string}**\"))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# x1 = consume_cpu(2**14) # about 1GB\n", "def consume_gpu(n): return torch.ones((n, n)).cuda()\n", "def consume_1gb(): return [consume_gpu(2**14)]\n", "def consume_6gb(): return [consume_1gb() for x in range(6) ]\n", "\n", "def reclaim():\n", " gc.collect()\n", " torch.cuda.empty_cache()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import tracemalloc, threading, torch, time, pynvml\n", "from fastai.utils.mem import *\n", "from fastai.vision import *\n", "\n", "if not torch.cuda.is_available(): raise Exception(\"pytorch is required\")\n", "\n", "def preload_pytorch():\n", " torch.ones((1, 1)).cuda()\n", " \n", "def gpu_mem_get_used_no_cache():\n", " torch.cuda.empty_cache()\n", " return gpu_mem_get().used\n", "\n", "def gpu_mem_used_get_fast(gpu_handle):\n", " info = pynvml.nvmlDeviceGetMemoryInfo(gpu_handle)\n", " return int(info.used/2**20)\n", "\n", "def torch_mem_report():\n", " torch.cuda.empty_cache()\n", " print(list(map(lambda x: int(x/2**20), [torch.cuda.memory_allocated(), torch.cuda.max_memory_allocated(), torch.cuda.memory_cached(), torch.cuda.max_memory_cached()])))\n", " \n", "preload_pytorch()\n", "pynvml.nvmlInit()\n", "\n", "class PeakMemMetric(LearnerCallback):\n", " _order=-20 # Needs to run before the recorder\n", "\n", " def peak_monitor_start(self):\n", " self.peak_monitoring = True\n", "\n", " # start RAM tracing\n", " tracemalloc.start()\n", "\n", " # this thread samples RAM usage as long as the current epoch of the fit loop is running\n", " peak_monitor_thread = threading.Thread(target=self.peak_monitor_func)\n", " peak_monitor_thread.daemon = True\n", " peak_monitor_thread.start()\n", " \n", " def peak_monitor_stop(self):\n", " tracemalloc.stop()\n", " self.peak_monitoring = False\n", " \n", " def peak_monitor_func(self):\n", " self.gpu_mem_used_peak = -1\n", "\n", " gpu_id = torch.cuda.current_device()\n", " gpu_handle = pynvml.nvmlDeviceGetHandleByIndex(gpu_id)\n", "\n", " while True:\n", " gpu_mem_used = gpu_mem_used_get_fast(gpu_handle)\n", " self.gpu_mem_used_peak = max(gpu_mem_used, self.gpu_mem_used_peak)\n", " if not self.peak_monitoring: break\n", " time.sleep(0.001) # 1msec\n", "\n", " def on_train_begin(self, **kwargs):\n", " self.learn.recorder.add_metric_names(['cpu used', 'peak', 'gpu used', 'peak'])\n", " \n", " def on_epoch_begin(self, **kwargs):\n", " self.peak_monitor_start()\n", " self.gpu_before = gpu_mem_get_used_no_cache()\n", "\n", " def on_epoch_end(self, **kwargs):\n", " cpu_current, cpu_peak = list(map(lambda x: int(x/2**20), tracemalloc.get_traced_memory()))\n", " gpu_current = gpu_mem_get_used_no_cache() - self.gpu_before\n", " gpu_peak = self.gpu_mem_used_peak - self.gpu_before\n", " self.peak_monitor_stop()\n", " # The numbers are deltas in MBs (beginning of the epoch and the end)\n", " self.learn.recorder.add_metrics([cpu_current, cpu_peak, gpu_current, gpu_peak])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Prep dataset" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "*** Experiment started with the Pytorch backend\n", "Device: ID 0, GeForce GTX 1070 Ti (8119 RAM)\n", "\n", "\n", "*** Current state:\n", "RAM: Used Free Total Util\n", "CPU: 2277 9470 31588 MB 7.21% \n", "GPU: 1474 6645 8119 MB 18.15% \n", "\n", "\n", "･ RAM: △Consumed △Peaked Used Total | Exec time 0.000s\n", "･ CPU: 0 0 2277 MB |\n", "･ GPU: 0 0 1474 MB |\n" ] } ], "source": [ "exp1 = IPyExperimentsPytorch()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.004s\n", "･ CPU: 0 1 2278 MB |\n", "･ GPU: 0 0 1474 MB |\n" ] } ], "source": [ "path = untar_data(URLs.MNIST)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.007s\n", "･ CPU: 0 0 2278 MB |\n", "･ GPU: 0 0 1474 MB |\n" ] } ], "source": [ "# setup\n", "defaults.cmap='binary'\n", "bs=512\n", "tfms = ([*rand_pad(padding=3, size=28, mode='zeros')], [])\n", "#arch=\"resnet34\"\n", "arch=\"resnet50\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "ImageItemList (70000 items)\n", "[Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28)]...\n", "Path: /home/stas/.fastai/data/mnist_png" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.512s\n", "･ CPU: 26 0 2350 MB |\n", "･ GPU: 0 0 1474 MB |\n" ] } ], "source": [ "il = ImageItemList.from_folder(path, convert_mode='L')\n", "il" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "ItemLists;\n", "\n", "Train: ImageItemList (60000 items)\n", "[Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28)]...\n", "Path: /home/stas/.fastai/data/mnist_png;\n", "\n", "Valid: ImageItemList (10000 items)\n", "[Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28)]...\n", "Path: /home/stas/.fastai/data/mnist_png;\n", "\n", "Test: None" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.115s\n", "･ CPU: 8 4 2360 MB |\n", "･ GPU: 0 0 1474 MB |\n" ] } ], "source": [ "sd = il.split_by_folder(train='training', valid='testing')\n", "sd" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.179s\n", "･ CPU: 0 0 2360 MB |\n", "･ GPU: 0 0 1474 MB |\n" ] } ], "source": [ "src = sd.label_from_folder()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.001s\n", "･ CPU: 0 0 2360 MB |\n", "･ GPU: 0 0 1474 MB |\n" ] } ], "source": [ "ll = src.transform(tfms)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.317s\n", "･ CPU: 0 1 2362 MB |\n", "･ GPU: 0 0 1474 MB |\n" ] } ], "source": [ "data = ll.databunch(bs=bs).normalize(imagenet_stats)\n", "x,y = data.train_ds[0]\n", "x.show()\n", "print(y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Train and Validate\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.001s\n", "･ CPU: 0 0 2362 MB |\n", "･ GPU: 0 0 1474 MB |\n" ] } ], "source": [ "model = getattr(models, arch) # models.resnet34" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.792s\n", "･ CPU: 0 0 2522 MB |\n", "･ GPU: 106 0 1580 MB |\n" ] } ], "source": [ "learn = create_cnn(data, model, metrics=[accuracy], callback_fns=PeakMemMetric)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", "･ RAM: △Consumed △Peaked Used Total | Exec time 16.813s\n", "･ CPU: 0 0 2532 MB |\n", "･ GPU: 14 6206 1594 MB |\n" ] } ], "source": [ "learn.lr_find()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", "･ RAM: △Consumed △Peaked Used Total | Exec time 12.733s\n", "･ CPU: 0 0 2533 MB |\n", "･ GPU: 0 964 1594 MB |\n" ] } ], "source": [ "# 2nd time to check for leaks\n", "learn.lr_find()\n", "# gpu delta consumed should be zero\n", "# but why peaked is much smaller?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.039s\n", "･ CPU: 0 0 2533 MB |\n", "･ GPU: 0 0 1594 MB |\n" ] } ], "source": [ "reclaim() # resets lr_find's GPU RAM consumption" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.025s\n", "･ CPU: 0 0 2533 MB |\n", "･ GPU: 0 0 1594 MB |\n" ] } ], "source": [ "learn.recorder.plot()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Total time: 00:19

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_lossaccuracycpu usedpeakgpu usedpeak
10.2163790.0624750.97920002423968
\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 19.321s\n", "･ CPU: 0 0 2533 MB |\n", "･ GPU: 26 3942 1620 MB |\n" ] } ], "source": [ "learn.fit_one_cycle(1, max_lr=1e-2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Total time: 00:17

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_lossaccuracycpu usedpeakgpu usedpeak
10.0769050.0334320.9895000214954
\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "Total time: 00:35

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_lossaccuracycpu usedpeakgpu usedpeak
10.0740240.0714920.9777000214954
20.0460480.0244210.991800026944
\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 54.109s\n", "･ CPU: 0 0 2534 MB |\n", "･ GPU: 0 958 1620 MB |\n" ] } ], "source": [ "# cycle this:\n", "learn.fit_one_cycle(1, max_lr=1e-2)\n", "learn.fit_one_cycle(2, max_lr=1e-2)\n", "learn.save(f'reload1')\n", "_=learn.load(f'reload1')\n", "reclaim() # resets lr_find's GPU RAM consumption" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.040s\n", "･ CPU: 0 0 2534 MB |\n", "･ GPU: 0 0 1620 MB |\n" ] } ], "source": [ "reclaim() # resets fit_one_cycle's GPU RAM consumption" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.187s\n", "･ CPU: 0 0 2534 MB |\n", "･ GPU: 0 0 1620 MB |\n" ] } ], "source": [ "learn.save(f'reload1')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Proposed Change\n", "end of `learn.load()` is a place where reclaim should be executed, so that the GPU RAM taken previously by the model is unloaded - otherwise it's doubled in size until gc.collect() arrives some time in the future.\n", "\n", "Currently, we get delta peaked reported @ 126MB for models.resnet34, and it should be 0 peaked, if first the model is unloaded and then loaded again." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.096s\n", "･ CPU: 0 0 2534 MB |\n", "･ GPU: 0 126 1620 MB |\n" ] } ], "source": [ "_=learn.load(f'reload1')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "**load() caused potential fragmentation by not unloading model first, delta peaked at 126 MB**" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.002s\n", "･ CPU: 0 0 2534 MB |\n", "･ GPU: 0 0 1620 MB |\n" ] } ], "source": [ "cpu_mem, gpu_mem, time_data = exp1.cl.data\n", "if b2mb(gpu_mem.peaked_delta) > 10:\n", " alert(f\"load() caused potential fragmentation by not unloading model first, delta peaked at {b2mb(gpu_mem.peaked_delta)} MB\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.040s\n", "･ CPU: 0 0 2534 MB |\n", "･ GPU: 0 0 1620 MB |\n" ] } ], "source": [ "reclaim() # resets load's GPU RAM consumption" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.052s\n", "･ CPU: 0 0 2534 MB |\n", "･ GPU: 0 0 1620 MB |\n" ] } ], "source": [ "#reclaim_tensors()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", "･ RAM: △Consumed △Peaked Used Total | Exec time 12.918s\n", "･ CPU: 0 0 2535 MB |\n", "･ GPU: 0 954 1620 MB |\n" ] } ], "source": [ "learn.lr_find(end_lr=1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "

" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.355s\n", "･ CPU: 0 1 2535 MB |\n", "･ GPU: 0 0 1620 MB |\n" ] } ], "source": [ "learn.recorder.plot()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Total time: 00:18

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_lossaccuracycpu usedpeakgpu usedpeak
10.0539310.0269530.991700024954
\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 18.119s\n", "･ CPU: 0 0 2535 MB |\n", "･ GPU: 0 954 1620 MB |\n" ] } ], "source": [ "learn.fit_one_cycle(1, max_lr=1e-2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.146s\n", "･ CPU: 0 0 2535 MB |\n", "･ GPU: 0 0 1620 MB |\n" ] } ], "source": [ "learn.save(f'leak2')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Fine tuning" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.096s\n", "･ CPU: 0 0 2535 MB |\n", "･ GPU: 0 126 1620 MB |\n" ] } ], "source": [ "_=learn.load(f'leak2')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.004s\n", "･ CPU: 0 0 2535 MB |\n", "･ GPU: 0 0 1620 MB |\n" ] } ], "source": [ "learn.unfreeze()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", "･ RAM: △Consumed △Peaked Used Total | Exec time 12.692s\n", "･ CPU: 0 0 2535 MB |\n", "･ GPU: 226 3486 1846 MB |\n" ] } ], "source": [ "learn.lr_find()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", "･ RAM: △Consumed △Peaked Used Total | Exec time 10.294s\n", "･ CPU: 0 0 2535 MB |\n", "･ GPU: 0 944 1846 MB |\n" ] } ], "source": [ "# 2nd time to check for leaks\n", "learn.lr_find()\n", "# gpu delta consumed should be zero" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "

" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.313s\n", "･ CPU: 0 1 2535 MB |\n", "･ GPU: 0 0 1846 MB |\n" ] } ], "source": [ "learn.recorder.plot()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "Total time: 00:21

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_lossvalid_lossaccuracycpu usedpeakgpu usedpeak
10.0405490.0240230.99180002510942
\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 21.576s\n", "･ CPU: 0 0 2535 MB |\n", "･ GPU: 494 432 2340 MB |\n" ] } ], "source": [ "lr=1e-2\n", "learn.fit_one_cycle(1, slice(1e-5, lr/5))\n", "# XXX: something is wrong here measurement-wise\n", "# callback reports peak of 942 vs. cell peak reports at 432 - the measuring thread of the cell probably missed that higher peak - need to switch to the new pytorch max_memory_allocated with reset_ to get the exact measurement. must wait for pytorch-1.0.1 to be out.\n", "# " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.359s\n", "･ CPU: 0 1 2535 MB |\n", "･ GPU: 0 0 2340 MB |\n" ] } ], "source": [ "learn.save(f'leak3')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.004s\n", "･ CPU: 0 0 2535 MB |\n", "･ GPU: 0 0 2340 MB |\n" ] } ], "source": [ "learn.freeze()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.178s\n", "･ CPU: 0 98 2535 MB |\n", "･ GPU: 0 0 2340 MB |\n" ] } ], "source": [ "learn.export()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Inference via learn.export" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.155s\n", "･ CPU: 3 106 2537 MB |\n", "･ GPU: 0 0 2340 MB |\n" ] } ], "source": [ "learn = load_learner(path, test=ImageItemList.from_folder(path/'testing'))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "LabelList\n", "y: EmptyLabelList (10000 items)\n", "[EmptyLabel , EmptyLabel , EmptyLabel , EmptyLabel , EmptyLabel ]...\n", "Path: .\n", "x: ImageItemList (10000 items)\n", "[Image (3, 28, 28), Image (3, 28, 28), Image (3, 28, 28), Image (3, 28, 28), Image (3, 28, 28)]...\n", "Path: /home/stas/.fastai/data/mnist_png" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "10000" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.004s\n", "･ CPU: 0 0 2537 MB |\n", "･ GPU: 0 0 2340 MB |\n" ] } ], "source": [ "learn.data.test_ds\n", "len(learn.data.test_ds)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 3.227s\n", "･ CPU: 0 0 2537 MB |\n", "･ GPU: 0 2596 2340 MB |\n" ] } ], "source": [ "predictions = learn.get_preds(ds_type=DatasetType.Test)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "10000" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.002s\n", "･ CPU: 0 0 2537 MB |\n", "･ GPU: 0 0 2340 MB |\n" ] } ], "source": [ "len(predictions[0])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1.266012e-07, 1.467593e-06, 9.686403e-07, 2.154748e-08, 9.999814e-01, 7.464445e-08, 3.189584e-06, 4.764192e-06,\n", " 2.979431e-06, 4.936371e-06], dtype=float32)" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/html": [ "

\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123456789
01.266012e-070.0000019.686403e-072.154748e-080.9999817.464445e-080.0000030.0000050.0000030.000005
12.941443e-050.0000846.121457e-058.575105e-060.9925411.012440e-050.0000670.0006260.0003380.006233
28.962942e-050.0001271.539169e-042.455930e-050.9752724.038281e-050.0001820.0003000.0008270.022983
31.213701e-070.0000022.753096e-072.414696e-080.9999701.101933e-070.0000030.0000050.0000050.000013
48.470987e-060.0000518.441069e-063.164073e-060.9979191.190504e-050.0000590.0000780.0011980.000663
\n", "
" ], "text/plain": [ " 0 1 2 3 4 5 \\\n", "0 1.266012e-07 0.000001 9.686403e-07 2.154748e-08 0.999981 7.464445e-08 \n", "1 2.941443e-05 0.000084 6.121457e-05 8.575105e-06 0.992541 1.012440e-05 \n", "2 8.962942e-05 0.000127 1.539169e-04 2.455930e-05 0.975272 4.038281e-05 \n", "3 1.213701e-07 0.000002 2.753096e-07 2.414696e-08 0.999970 1.101933e-07 \n", "4 8.470987e-06 0.000051 8.441069e-06 3.164073e-06 0.997919 1.190504e-05 \n", "\n", " 6 7 8 9 \n", "0 0.000003 0.000005 0.000003 0.000005 \n", "1 0.000067 0.000626 0.000338 0.006233 \n", "2 0.000182 0.000300 0.000827 0.022983 \n", "3 0.000003 0.000005 0.000005 0.000013 \n", "4 0.000059 0.000078 0.001198 0.000663 " ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.038s\n", "･ CPU: 0 0 2537 MB |\n", "･ GPU: 0 0 2340 MB |\n" ] } ], "source": [ "# get predictions as numpy\n", "pred = predictions[0].numpy()\n", "pred[0]\n", "pred_df = pd.DataFrame(pred)\n", "pred_df[:5]\n", "#pred_df.sort_values(by=\"preds\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Inference with manual learn re-construction" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.046s\n", "･ CPU: 0 0 2537 MB |\n", "･ GPU: 0 0 2340 MB |\n" ] } ], "source": [ "del learn\n", "gc.collect()\n", "#learn.opt.clear()\n", "torch.cuda.empty_cache()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.000s\n", "･ CPU: 0 0 2537 MB |\n", "･ GPU: 0 0 2340 MB |\n" ] } ], "source": [ "#del exp1" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.025s\n", "･ CPU: 0 0 2537 MB |\n", "･ GPU: 0 0 2340 MB |\n" ] } ], "source": [ "bs = 32\n", "tfms = get_transforms(do_flip=False)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.936s\n", "･ CPU: 3 1 2552 MB |\n", "･ GPU: -460 654 1880 MB |\n" ] } ], "source": [ "data = (src.add_test_folder(test_folder='testing')\n", " .transform(tfms) # .transform(tfms, size=256)\n", " .databunch().normalize(imagenet_stats))\n", "learn = create_cnn(data, model)\n", "_=learn.load(f'leak3')\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.000s\n", "･ CPU: 0 0 2552 MB |\n", "･ GPU: 0 0 1880 MB |\n" ] } ], "source": [ "# learn.data = (src.add_test_folder(test_folder='test')\n", "# .transform(tfms) # .transform(tfms, size=256)\n", "# .databunch().normalize(imagenet_stats))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "LabelList\n", "y: EmptyLabelList (10000 items)\n", "[EmptyLabel , EmptyLabel , EmptyLabel , EmptyLabel , EmptyLabel ]...\n", "Path: .\n", "x: ImageItemList (10000 items)\n", "[Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28)]...\n", "Path: /home/stas/.fastai/data/mnist_png" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "10000" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.039s\n", "･ CPU: 0 0 2552 MB |\n", "･ GPU: 0 0 1880 MB |\n" ] } ], "source": [ "learn.data.test_ds\n", "len(learn.data.test_ds)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.000s\n", "･ CPU: 0 0 2551 MB |\n", "･ GPU: 0 0 1880 MB |\n" ] } ], "source": [ "#learn.validate()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 2.293s\n", "･ CPU: 0 0 2552 MB |\n", "･ GPU: 0 0 1880 MB |\n" ] } ], "source": [ "predictions = learn.get_preds(ds_type=DatasetType.Test)\n", "\n", "# need to also try learn.TTA()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "10000" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.002s\n", "･ CPU: 0 0 2552 MB |\n", "･ GPU: 0 0 1880 MB |\n" ] } ], "source": [ "len(predictions[0])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1.266012e-07, 1.467593e-06, 9.686403e-07, 2.154748e-08, 9.999814e-01, 7.464445e-08, 3.189584e-06, 4.764192e-06,\n", " 2.979431e-06, 4.936371e-06], dtype=float32)" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123456789
01.266012e-070.0000019.686403e-072.154748e-080.9999817.464445e-080.0000030.0000050.0000030.000005
12.941443e-050.0000846.121457e-058.575105e-060.9925411.012440e-050.0000670.0006260.0003380.006233
28.962942e-050.0001271.539169e-042.455930e-050.9752724.038281e-050.0001820.0003000.0008270.022983
31.213701e-070.0000022.753096e-072.414696e-080.9999701.101933e-070.0000030.0000050.0000050.000013
48.470987e-060.0000518.441069e-063.164073e-060.9979191.190504e-050.0000590.0000780.0011980.000663
\n", "
" ], "text/plain": [ " 0 1 2 3 4 5 \\\n", "0 1.266012e-07 0.000001 9.686403e-07 2.154748e-08 0.999981 7.464445e-08 \n", "1 2.941443e-05 0.000084 6.121457e-05 8.575105e-06 0.992541 1.012440e-05 \n", "2 8.962942e-05 0.000127 1.539169e-04 2.455930e-05 0.975272 4.038281e-05 \n", "3 1.213701e-07 0.000002 2.753096e-07 2.414696e-08 0.999970 1.101933e-07 \n", "4 8.470987e-06 0.000051 8.441069e-06 3.164073e-06 0.997919 1.190504e-05 \n", "\n", " 6 7 8 9 \n", "0 0.000003 0.000005 0.000003 0.000005 \n", "1 0.000067 0.000626 0.000338 0.006233 \n", "2 0.000182 0.000300 0.000827 0.022983 \n", "3 0.000003 0.000005 0.000005 0.000013 \n", "4 0.000059 0.000078 0.001198 0.000663 " ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "name": "stdout", "output_type": "stream", "text": [ "･ RAM: △Consumed △Peaked Used Total | Exec time 0.037s\n", "･ CPU: 0 0 2552 MB |\n", "･ GPU: 0 0 1880 MB |\n" ] } ], "source": [ "# get predictions as numpy\n", "pred = predictions[0].numpy()\n", "pred[0]\n", "pred_df = pd.DataFrame(pred)\n", "pred_df[:5]\n", "#pred_df.sort_values(by=\"preds\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" } }, "nbformat": 4, "nbformat_minor": 2 }