wraping up images\n",
- " view_images(\n",
- " img1, img2, img3,\n",
- " img4, img5, img6,\n",
- " img7)()\n",
- " \"\"\"\n",
- " from forgebox.html import DOM\n",
- " frame = DOM(\"\", \"div\", {\"class\": \"row\"})\n",
- " assert num_per_row in [1, 2, 3, 4, 6, 12],\\\n",
- " \"num_per_row should be in [1, 2, 3, 4, 6, 12]\"\n",
- " col = 12//num_per_row\n",
- "\n",
- " if titles is not None:\n",
- " assert len(titles) == len(images),\\\n",
- " f\"title length:{len(titles)}!=image length:({len(images)})\"\n",
- " if titles is None:\n",
- " for img in images:\n",
- " frame.append(image_dom(img, **{\"class\": f\"col-sm-{col}\"}))\n",
- " else:\n",
- " for img, title in zip(images, titles):\n",
- " frame.append(with_title_dom(img, title, col))\n",
- " return frame"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Subplot"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
+ "execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
- "# export\n",
- "class Subplots:\n",
- " \"\"\"\n",
- " Simplifying plt sublots\n",
- " sub = Subplots(18)\n",
- "\n",
- " ```\n",
- " @sub.single\n",
- " def plotting(ax, data):\n",
- " ax.plot(data)\n",
- "\n",
- " for data in data_list:\n",
- " sub(data)\n",
- " ```\n",
- " \"\"\"\n",
- "\n",
- " def __init__(self, total: int, ncol: int = 3, figsize=None):\n",
- " \"\"\"\n",
- " total:int, total plot numbers\n",
- " ncol:int, number of columns\n",
- " figsize: Tuple, default (15, vertical_items*4)\n",
- " \"\"\"\n",
- " from matplotlib import pyplot as plt\n",
- "\n",
- " self.i = 0\n",
- " self.size = list([math.ceil(float(total)/float(ncol)), ncol])\n",
- " self.ncol = ncol\n",
- " self.total = total\n",
- " self.figsize = figsize if figsize is not None else (15, self.size[0]*4)\n",
- " self.fig, self.ax = plt.subplots(*self.size, figsize=self.figsize)\n",
- "\n",
- " def __len__(self) -> int: return self.total\n",
- "\n",
- " def single(self, f: Callable) -> Callable:\n",
- " \"\"\"\n",
- " Decorating a plt subplot function\n",
- " \"\"\"\n",
- " self.single_func = f\n",
- " return self.single_func\n",
- "\n",
- " def __call__(self, *args, **kwargs):\n",
- " if self.i >= self.total:\n",
- " raise StopIteration(f\"You said total would be {self.total}!\")\n",
- " ax = self.ax[math.floor(\n",
- " float(self.i)/float(self.ncol)), self.i % self.ncol]\n",
- " self.single_func(ax, *args, **kwargs)\n",
- " self.i += 1"
+ "from forgebox.images.widgets import image_dom, with_title_dom, view_images, Subplots\n",
+ "import os"
]
},
{
@@ -187,15 +39,6 @@
"## Test on image preview"
]
},
- {
- "cell_type": "code",
- "execution_count": 13,
- "metadata": {},
- "outputs": [],
- "source": [
- "import os"
- ]
- },
{
"cell_type": "markdown",
"metadata": {},
@@ -345,7 +188,7 @@
],
"metadata": {
"kernelspec": {
- "display_name": "Python 3",
+ "display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
diff --git a/nbs/CUDA_GPU_Management.ipynb b/nbs/CUDA_GPU_Management.ipynb
index dddb904..6b15f59 100644
--- a/nbs/CUDA_GPU_Management.ipynb
+++ b/nbs/CUDA_GPU_Management.ipynb
@@ -15,15 +15,6 @@
"## Handler on a single CUDA device"
]
},
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# default_exp ftorch.cuda"
- ]
- },
{
"cell_type": "markdown",
"metadata": {},
@@ -40,122 +31,8 @@
"metadata": {},
"outputs": [],
"source": [
- "# export \n",
"import torch\n",
- "import subprocess\n",
- "\n",
- "class CudaDevice(object):\n",
- " def __init__(self, idx):\n",
- " \"\"\"\n",
- " idx: int, cuda device id\n",
- " d = CudaDevice(0)\n",
- " print(d)\n",
- " \"\"\"\n",
- " self.idx = idx\n",
- " self.device = torch.device(idx)\n",
- " if hasattr(self, \"used\") == False:\n",
- " self.refresh()\n",
- "\n",
- " def __repr__(self):\n",
- " return f\"Device {self.idx}: \\n\\tname:{self.prop.name}\\n\\tused:{self.used}MB\\tfree:{self.free}MB\"\n",
- "\n",
- " @property\n",
- " def prop(self):\n",
- " \"\"\"\n",
- " property on cuda device\n",
- " \"\"\"\n",
- " return torch.cuda.get_device_properties(self.idx)\n",
- "\n",
- " def __len__(self):\n",
- " return int(self.prop.total_memory)\n",
- "\n",
- " @property\n",
- " def mem(self):\n",
- " return f\"{self.__len__() // 1024 // 1024} MB\"\n",
- "\n",
- " def __int__(self):\n",
- " return int(self.idx)\n",
- "\n",
- " def refresh(self):\n",
- " gpu_stats = subprocess.check_output([\"nvidia-smi\", \"--format=csv\", \"--query-gpu=memory.used,memory.free\"])\n",
- " stat = list(\n",
- " int(v) for v in str(gpu_stats).split(\"\\\\n\")[1 + self.idx].replace(\" MiB\", \"\").replace(\" \", \"\").split(\",\"))\n",
- " setattr(self, \"used\", stat[0])\n",
- " setattr(self, \"free\", stat[1])\n",
- " return stat\n",
- "\n",
- " def __call__(self):\n",
- " return self.device"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## A handler managing multiple devices"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [],
- "source": [
- "# export \n",
- "class CudaHandler(object):\n",
- " def __init__(self):\n",
- " \"\"\"\n",
- " ch = CudaHandler()\n",
- " dev = ch.idle()()\n",
- " some_torch_tensor.to(dev)\n",
- " \"\"\"\n",
- " if torch.cuda.is_available() == False:\n",
- " return None\n",
- " self.counts = torch.cuda.device_count()\n",
- " print(f\">>> {self.counts} cuda devices found >>>\")\n",
- " self.devices = list()\n",
- " for i in range(self.counts):\n",
- " d = CudaDevice(i)\n",
- " self.devices.append(d)\n",
- " print(f\"{d}\")\n",
- " setattr(self, f\"gpu{i}\", d)\n",
- "\n",
- " def __len__(self):\n",
- " \"\"\"\n",
- " counts of the cuda devices numbers\n",
- " \"\"\"\n",
- " return self.counts\n",
- "\n",
- " def __getitem__(self, idx):\n",
- " return self.devices[idx]\n",
- "\n",
- " def __repr__(self):\n",
- " self.refresh()\n",
- " return f\"<{self.counts} cuda devices>\\n\" + \"\\n\".join(list(str(d) for d in (self.devices)))\n",
- "\n",
- " def refresh(self):\n",
- " \"\"\"\n",
- " refresh the cuda mem stats\n",
- " \"\"\"\n",
- " gpu_stats = subprocess.check_output([\"nvidia-smi\", \"--format=csv\", \"--query-gpu=memory.used,memory.free\"])\n",
- " rows = list(list(int(v) for v in vs.replace(\" MiB\", \"\").replace(\" \", \"\").split(\",\")) for vs in\n",
- " str(gpu_stats).split(\"\\\\n\")[1:-1])\n",
- " for i in range(len(rows)):\n",
- " setattr(self.devices[i], \"used\", rows[i][0])\n",
- " setattr(self.devices[i], \"free\", rows[i][1])\n",
- " print(\"cuda stats refreshed\")\n",
- "\n",
- " def idle(self):\n",
- " \"\"\"\n",
- " find the most idle cuda device\n",
- " \"\"\"\n",
- " self.refresh()\n",
- " rt = self[0]\n",
- " for d in self.devices:\n",
- " if d.free > rt.free:\n",
- " rt = d\n",
- " print(f\"Found the most idle GPU: cuda:{rt.idx}, {rt.free} MB Mem remained\")\n",
- " return rt"
+ "from forgebox.ftorch.cuda import CudaDevice, CudaHandler, Cudas"
]
},
{
@@ -169,22 +46,8 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "These handler is to simplify the multi-cuda situation, where you can allocate the most idle GPU"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "from forgebox.ftorch.cuda import CudaHandler"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
+ "These handler is to simplify the multi-cuda situation, where you can allocate the most idle GPU\n",
+ "\n",
"Substantiate the handler"
]
},
@@ -232,7 +95,7 @@
],
"metadata": {
"kernelspec": {
- "display_name": "Python 3",
+ "display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
@@ -247,6 +110,19 @@
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.4"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": true,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
}
},
"nbformat": 4,