{"slug": "show-hn-svetoviz-visual-debugger-for-large-language-models", "title": "Show HN: Svetoviz – Visual debugger for large language models", "summary": "Svetoviz, a new Python package installable via `pip install svetoviz`, provides a visual debugger that streams tensors, images, NumPy arrays, Hugging Face datasets and PyTorch models to a custom WebGPU renderer running in a browser tab. The package includes a PyTorch debugger that traces the input-to-weights-to-output relation of every basic `torch.nn` module, and supports macOS (Apple Silicon) and Linux on x86_64/aarch64 with Python 3.9 through 3.14. Scenes are built from Views and Layouts and can be saved to disk as tiles plus a tree.db and converted with `sv.build_pmtiles_file()` for a remote URL, with the renderer running locally so no account or server-side compute is required.", "body_md": "### High-dimensional data visualization for NumPy, PyTorch, Hugging Face datasets and entire neural networks.\n\n**Svetoviz is a debug viewer for tensors, images, NumPy arrays, datasets and PyTorch models.** It ships as a\nsingle Python package (`svetoviz`) that streams your scene to a custom **WebGPU renderer** running in the browser,\nand includes a **PyTorch debugger** that traces the *input -> weights -> output* relation of every basic `torch.nn`\nmodule.\n\nEvery section below mirrors the matching page of the documentation site ([https://www.svetoviz.com/docs](https://www.svetoviz.com/docs)) one to one, in the same order. The section-to-page mapping, including the reference script, is listed in [Documentation Index](#13-documentation-index).\n\nSvetoviz is a high-dimensional data visualization engine. It ships with a custom WebGPU renderer that renders entire models and datasets in the browser, and a Python package (`svetoviz`) that lets you build your own visualizations with your own data.\n\nYour Python process builds a scene out of **Views** (data sources) and **Layouts** (spatial containers) and hands it to a renderer. Values are never flattened into a print statement or a single 2D image: every element gets a position in 3D space, and you navigate that space.\n\n- **Model visualization:** render entire models and datasets in the browser via the custom WebGPU renderer, or open the scene directly from the public spaces directory.\n- **Dataset browser:** visualize large datasets in the browser, or open the scene directly from the public spaces directory.\n- **PyTorch Debugger:** track the input -> weights -> output relations for every basic PyTorch module.\n- **Your own data:** build views from your own models, datasets and NumPy arrays with the Python package and open them in the browser - the renderer runs locally, no account needed.\n\n| Package | Renders in | macOS (Apple Silicon) | Linux | Python | \n|---|---|---|---|---|\n| `svetoviz` | A modern browser (Chrome / Chromium WebGPU) | Yes | Yes ( `x86_64` /`aarch64` ) | **3.9 - 3.14** | \n\nThe single `svetoviz` package exposes one surface - `sv.array`, `sv.tensor`, `sv.image`, `sv.view`, `sv.pytorch`, `sv.model`, `sv.pipeline`, `sv.save_to_disk`, `sv.load_from_disk` - backed by one mapping implementation. It streams the scene to a browser tab and renders it client-side with a custom WebGPU pipeline: the renderer runs locally, so no account and no server-side compute are required.\n\n```\nyour python process                         renderer                        user\n---------------------                       --------                        ----\nnumpy / torch / PIL / HF dataset\n        |\n        +-- Views (NumpyView, TensorView, DatasetView, ModelView, ...)\n        |\n        +-- Layouts (Vertical / Horizontal / Grid / Directory / Spiral)\n        |\n        +-- sv.view(scene)  ------------->  WebGPU  (browser)  --------->  3D scene\n\nsv.save_to_disk(scene) --> tiles + tree.db --> sv.build_pmtiles_file() --> remote URL\n```\n\nThis README mirrors the documentation site section by section. Every code block below is taken from the corresponding documentation page or from the reference script in this repository.\n\n```\n.\n|-- README.md                       # this document (GitHub landing page)\n|-- app.py                          # local preview renderer for README.md (not part of the package)\n|-- examples/\n|   `-- quickstart_webgpu.py        # reference script for svetoviz\n`-- assets/\n    `-- images/                     # every screenshot embedded in this README\n```\n\nSvetoviz is currently distributed via pip.\n\nInstall the Svetoviz package (WebGPU renderer) with the following command:\n\n```\npip install svetoviz\n```\n\nOr using a private repository:\n\n```\npip install svetoviz --extra-index-url https://svetoviz.com/webgpu/simple/\n```\n\n**Compatibility:** this package supports **macOS (Apple Silicon), Linux** and Python versions **3.9 through 3.14**.\n\nDependencies installed with the Svetoviz package:\n\n```\ndependencies = [\n    \"Flask>=3.1,<4\",\n    \"flask-cors>=6.0,<7\",\n    \"waitress>=3.0,<4\",\n    \"websockets>=15,<16\",\n    \"opencv-python>=4.10\",\n    \"psd-tools==1.11.0\",\n    \"pmtiles==3.7.0\",\n    \"petname==2.9\",\n    \"requests>=2.32,<3\",\n    \"transformers>=4.57,<6\",\n    \"torch>=2.8\",\n    \"datasets>=4.5,<6\",\n]\n```\n\n**Quick start:** download [`examples/quickstart_webgpu.py`](https://github.com/PiotrGryko/svetoviz/blob/main/examples/quickstart_webgpu.py) for the full reference script. The minimal starting point from that file:\n\n``` python\n# examples/quickstart_webgpu.py\nimport os\n\ncurrent_dir = os.path.dirname(os.path.abspath(__file__))\ncache_dir = os.path.join(current_dir, \"cache_test\")\nos.environ[\"SVETO_VIZ_CACHE_DIR\"] = cache_dir\n\nimport svetoviz as sv\nimport numpy as np\n\nprint(f\"Cache dir: {sv.get_cache_dir()}\")\n\ndata = np.random.rand(4, 4, 32, 32).astype(np.float32)\nsv.array(data, gap_size=10)  # opens http://localhost:8000\n```\n\nCache data is written to `SVETO_VIZ_CACHE_DIR`. Set the variable **before** importing svetoviz, otherwise cache data gets stored inside site packages:\n\n``` python\nimport os\n\ncurrent_dir = os.path.dirname(os.path.abspath(__file__))\ncache_dir = os.path.join(current_dir, \"cache_test\")\nos.environ[\"SVETO_VIZ_CACHE_DIR\"] = cache_dir\n\nimport svetoviz as sv\n\n# Verify the cache\nprint(f\"Cache dir: {sv.get_cache_dir()}\")\n```\n\nRun the demo to verify the installation:\n\n``` python\nimport svetoviz as sv\n\n# Run web demo\nsv.demo_array()\n\n# Run web pytorch demo\nsv.demo_modules()\n```\n\n`sv.demo_modules()` opens a collection of all supported PyTorch modules. Pass any string into the terminal view to process them, then use the timeline view to walk through the activations.\n\nMethod definitions and parameter specifications for the `svetoviz` package.\n\n`svetoviz`\n\n| Signature | \n|---|\n| `array(cls, np_array, gap_size=0, ordering=None, host=\"localhost\", http_port=8000, ws_port=8765, config=None)` | \n| `arrays(cls, arrays, gap_size=0, host=\"localhost\", http_port=8000, ws_port=8765, config=None)` | \n| `tensor(cls, tensor, gap_size=0, ordering=None, host=\"localhost\", http_port=8000, ws_port=8765, config=None)` | \n| `tensors(cls, tensors, gap_size=0, host=\"localhost\", http_port=8000, ws_port=8765, config=None)` | \n| `image(cls, image, host=\"localhost\", http_port=8000, ws_port=8765, config=None)` | \n| `images(cls, images, host=\"localhost\", http_port=8000, ws_port=8765, config=None)` | \n| `pytorch(cls, module, terminal_callback=None, host=\"localhost\", http_port=8000, ws_port=8765, blocking=True, config=None)` | \n| `model(cls, id, model, tokenizer=None, image_processor=None, video_processor=None, processor=None, scheduler=None, feature_extractor=None, terminal_callback=None, host=\"localhost\", http_port=8000, ws_port=8765, blocking=True, config=None)` | \n| `pipeline(cls, id, pipe, terminal_callback=None, host=\"localhost\", http_port=8000, ws_port=8765, blocking=True, config=None)` | \n| `view(cls, view, terminal_callback=None, host=\"localhost\", http_port=8000, ws_port=8765, config=None)` | \n| `save_to_disk(cls, view, directory, threaded=True, max_memory_gb=2, image_backend=\"pillow\", compression=\"png_0\")` | \n| `load_from_disk(cls, directory, host=\"localhost\", http_port=8000, ws_port=8765, config=None)` | \n| `build_pmtiles_file(cls, directory)` | \n| `demo_array(cls, host=\"localhost\", http_port=8000)` | \n| `demo_modules(cls, host=\"localhost\", http_port=8000)` | \n\n**Parameter notes**\n\n- `gap_size` - integer spacing between visualized slices. Default`0` .\n- `ordering` - tuple or list defining the axis permutation, identical to`numpy.transpose` . The visualizer treats the**last two dimensions** as width and height, so arrays in`(H, W, C)` layout appear distorted and must be reordered, e.g.`ordering=(2, 0, 1)` .\n- `image` - accepts a URL string, a local file path, or a Pillow`Image` instance.\n\nEvery web method accepts an optional `config=WebConfig()` argument that controls the rendering of the scene:\n\n``` python\nclass WebConfig:\n    def __init__(self,\n                 # scene description\n                 description=None,\n                 # Theme name, \"Light\" \"Dark\" \"Darker\"\n                 default_theme=\"Dark\",\n                 # groups rendering mode, \"lines\", \"none\"\n                 groups_mode=\"lines\",\n                 # matrix mode (values up close), \"quads\", \"cubes\", \"diamonds\", \"spheres\"\n                 matrix_mode=\"quads\",\n                 # stream values (local only) - stream values on mouse hover\n                 stream_values=True,\n                 # terminal and timeline - enable/disable terminal and timeline view\n                 terminal_enabled=True,\n                 # render labels - enable/disable TextViews.\n                 render_labels=True\n                 ):\n```\n\n| Class | Signature | \n|---|---|\n| `NumpyView` | `__init__(self, id, data, gap_size=1, ordering=None, description=None)` | \n| `TensorView` | `__init__(self, id, data, gap_size=1, ordering=None, description=None)` | \n| `LazyImageView` | `__init__(self, id, image, description=None)` | \n| `DiskImageView` | `__init__(self, id, image, description=None)` | \n| `DirectoryGridView` | `__init__(self, id, directory, lazy=False, limit=None)` | \n| `DirectorySpiralView` | `__init__(self, id, directory, lazy=False, limit=None)` | \n| `DatasetView` | `__init__(self, id, dataset, image_columns, info_columns, cell_width, cell_height, image_backend, info_column_mapping_func)` | \n| `ModelView` | `__init__(self, id, model, tokenizer=None, image_processor=None, video_processor=None, processor=None, scheduler=None, feature_extractor=None)` | \n| `PipelineView` | `__init__(self, id, pipe)` | \n| `DiskSceneView` | `__init__(self, id, directory)` | \n\n| Class | Signature | \n|---|---|\n| `VerticalLayout` | `__init__(self, id, views, title=None, title_color=None, padding=None, spacing=None, gravity=None, background_color=None)` | \n| `HorizontalLayout` | `__init__(self, id, views, title=None, title_color=None, padding=None, spacing=None, gravity=None, background_color=None)` | \n| `GridLayout` | `__init__(self, id, views, title=None, title_color=None, padding=None, spacing=None, background_color=None)` | \n\n| Class | Signature | \n|---|---|\n| `RemotePmTilesView(VerticalLayout)` | `__init__(self, id, pm_tiles_url, tree_db_file)` | \n| `RemoteTilesView(VerticalLayout)` | `__init__(self, id, depth, tile_width, tile_height, url_pattern)` | \n\n| Call | Effect | \n|---|---|\n| `get_cache_dir()` | Resolve the current cache directory | \n| `save_to_disk(view, directory, ...)` | Write a scene into tiles plus a `tree.db` | \n| `load_from_disk(directory)` | Open a built scene without the original data | \n| `build_pmtiles_file(directory)` | Turn a built scene into a PMTiles pyramid for remote hosting | \n\nInside a `terminal_callback(buffer, message, images, files)`:\n\n| Call | Effect | \n|---|---|\n| `buffer.send_user_message(text)` | Echo text as a user line in the terminal | \n| `buffer.send_system_message(text)` | Print a system line in the terminal | \n\nSvetoviz handles the full NumPy and PyTorch dtype spectrum:\n\n`bool`, `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`, `float16`, `bfloat16`, `float32`, `float64`, `complex32`, `complex64`, `complex128`.\n\nSvetoviz provides native support for image data, abstracting away the boilerplate of loading and pre-processing. Whether dealing with local high-resolution TIFs, web-based JPGs, or in-memory PIL objects, the engine renders them directly into the 3D environment.\n\nThe `image` method is polymorphic. It accepts local file paths, remote URLs, or existing Pillow (PIL) image objects. This is the fastest way to verify data integrity or inspect high-bit-depth scientific imagery.\n\n``` python\nimport svetoviz as sv\n\n# Supports URL, local path, or PIL object\nfilepath = \"/datasets/nasaimages/heic2409a.tif\"\n\nsv.image(filepath)\n```\n\n| Color map turbo | Zoom in to single pixel | \n|---|---|\n\nFor multiple images, `images` allows you to pass a list of mixed-source images. The engine tiles them in 3D space, enabling you to rotate and zoom through entire batches.\n\n``` python\nimport svetoviz as sv\n\nimage1_url = \"https://t4.ftcdn.net/jpg/02/70/3...\"\nimage2_url = \"https://www.mamp.one/wp-content/...\"\nimage3_url = \"https://img.freepik.com/free-photo/...\"\nfilepath1 = \"random_images/random_image_1.jpg\"\nfilepath2 = \"/datasets/nasaimages/heic1007a.tif\"\nfilepath3 = \"/datasets/nasaimages/heic2409b.tif\"\nfilepath4 = \"/datasets/nasaimages/heic2409a.tif\"\n\nsv.images(images=[\n    image1_url, image2_url, image3_url,\n    filepath1, filepath2, filepath3, filepath4\n])\n```\n\nImages processed via `image` and `images` are loaded eagerly and streamed directly from disk to ensure low latency during inspection. You can explicitly define the storage location for cached assets by modifying the global configuration:\n\n``` python\n# Set an environment variable for caching\nimport os\nos.environ[\"SVETO_VIZ_CACHE_DIR\"] = \"/path/to/your/custom/cache\"\n\nimport svetoviz as sv\n\n# Verify cache directory\ncurrent_cache = sv.get_cache_dir()\n```\n\nWhile these methods are optimized for rapid previews and medium-sized batches, they are not intended for massive datasets. For high-performance scenes containing hundreds of thousands of images, use the **Views API** for tile-based, lazy-loading spatial optimization.\n\nThe core of Svetoviz is its ability to handle raw NumPy arrays of any dimension and data type. Whether you are inspecting a single tensor or a collection of disparate arrays, the engine provides 3D spatial awareness for every element.\n\nUse `array` to project a single NumPy array into the 3D scene. The `gap_size` parameter controls the visual spacing between high-dimensional slices, making it easier to identify patterns across tensors.\n\n``` python\nimport svetoviz as sv\n\ndata = np.random.rand(4, 4, 32, 32).astype(np.float32)\n\nsv.array(data, gap_size=10)\n```\n\nSvetoviz handles high-dimensional tensors by \"stacking\" them along specific axes. This transforms multidimensional data into a physical 3D structure where numerical values are mapped to visual gradients in real time.\n\n| Dimensional stacking | Colormap application | \n|---|---|\n\nSvetoviz supports the full spectrum of NumPy dtypes - from standard integers and floats to complex numbers and booleans. Using `arrays`, you can pass a list of arrays with varying shapes and types.\n\n``` python\nimport svetoviz as sv\n\nsv.arrays([\n    # integers\n    np.random.randint(np.iinfo(np.int8).min, np.iinfo(np.int8).max, (2, 2, 128, 128), dtype=np.int8),\n    np.random.randint(np.iinfo(np.int16).min, np.iinfo(np.int16).max, (2, 3, 128, 128), dtype=np.int16),\n    np.random.randint(np.iinfo(np.int32).min, np.iinfo(np.int32).max, (4, 4, 64, 64), dtype=np.int32),\n    np.random.randint(np.iinfo(np.int64).min, np.iinfo(np.int64).max, (4, 2, 32, 64), dtype=np.int64),\n    np.random.randint(np.iinfo(np.uint8).min, np.iinfo(np.uint8).max, (2, 3, 128, 128), dtype=np.uint8),\n    np.random.randint(np.iinfo(np.uint16).min, np.iinfo(np.uint16).max, (16, 128, 128), dtype=np.uint16),\n    np.random.randint(np.iinfo(np.uint32).min, np.iinfo(np.uint32).max, (4, 4, 64, 64), dtype=np.uint32),\n    np.random.randint(np.iinfo(np.uint64).min, np.iinfo(np.uint64).max, (4, 2, 32, 64), dtype=np.uint64),\n    np.random.randint(np.iinfo(np.ubyte).min, np.iinfo(np.ubyte).max, (16, 16, 16), dtype=np.ubyte),\n    np.random.randint(np.iinfo(np.byte).min, np.iinfo(np.byte).max, (8, 2, 24, 24), dtype=np.byte),\n    np.random.randint(np.iinfo(np.intp).min, np.iinfo(np.intp).max, (64, 64), dtype=np.intp),\n    np.random.randint(np.iinfo(np.uintp).min, np.iinfo(np.uintp).max, (64, 64), dtype=np.uintp),\n    np.random.choice([True, False], (2, 72, 72)).astype(np.bool_),\n\n    # floats\n    (np.random.uniform(-1, 1, (256, 256)) * np.finfo(np.float16).max).astype(np.float16),\n    (np.random.uniform(-1, 1, (32, 32, 32)) * np.finfo(np.float32).max).astype(np.float32),\n    (np.random.uniform(-1, 1, (4, 3, 32, 32)) * np.finfo(np.float64).max).astype(np.float64),\n\n    # complex numbers\n    (np.random.randn(32, 32) + 1j * np.random.randn(32, 32)).astype(np.complex64),\n    (np.random.randn(32, 32) + 1j * np.random.randn(32, 32)).astype(np.complex128),\n], gap_size=32)\n```\n\nBy default, Svetoviz expects the last two dimensions of an array to represent the spatial height and width `(H, W)`. When passing standard image data in `(H, W, C)` format, the engine renders the channels as the spatial grid, resulting in a distorted view.\n\n``` python\nimport svetoviz as sv\n\n# Standard PIL to NumPy conversion results in (H, W, C)\ndata = np.array(image)\n\n# This will render incorrectly as it treats 'C' as part of the (H, W) pair\nsv.array(data, gap_size=0)\n```\n\nTo resolve this, use the `ordering` parameter to transpose the axes for the 3D projection without modifying the original array in memory. For a standard `(H, W, C)` image, use `ordering=(2, 0, 1)` to correctly map the dimensions.\n\n``` python\nimport svetoviz as sv\n\n# Standard PIL to NumPy conversion results in (H, W, C)\ndata = np.array(image)\n\n# Correctly map (H, W, C) to (C, H, W) for the 3D scene\nsv.array(data, gap_size=0, ordering=(2, 0, 1))\n```\n\nSvetoviz handles large arrays with ease. You can, for example, see all frames from a videoclip at once, allowing for a comprehensive spatial overview of temporal data.\n\n``` python\nimport svetoviz as sv\n\n# Load your video as a numpy array\narray = video_to_5d_grid('bunny.mp4')\nsv.array(array)\n```\n\nSvetoviz provides integrated support for the Hugging Face `datasets` ecosystem. By utilizing the `DatasetView`, you can transform massive remote repositories into persistent, locally-browsable 3D environments with optimized image tiling.\n\n``` python\nimport svetoviz as sv\nfrom datasets import load_dataset\n\nhf_name = \"Dewa/Dog_Emotion_Dataset_v2\"\ndataset = load_dataset(hf_name, split=\"train\")\n\nlayout = sv.DatasetView(\n    id=hf_name,\n    dataset=dataset,\n    image_columns=[\"image\"],\n    info_columns=[\"emotion\"],\n    cell_width=400,\n    cell_height=400\n)\n\nsv.save_to_disk(\n    view=layout,\n    compression=\"png_0\",\n    directory=output_directory\n)\n```\n\n`DatasetView` parameters:\n\n| Parameter | Meaning | \n|---|---|\n| `id` | Scene / dataset identifier shown in the viewer | \n| `dataset` | A `datasets.Dataset` (or a`select()` subset of it) | \n| `image_columns` | Columns holding images to tile into the grid | \n| `info_columns` | Text columns indexed into the search database | \n| `cell_width` /`cell_height` | Pixel size of each rendered entry | \n| `image_backend` | Pillow or the alternative image backend | \n| `info_column_mapping_func` | Maps raw ids to human labels | \n\n``` python\nimport svetoviz as sv\n\nsv.load_from_disk(directory=output_directory)\n```\n\nInclude `info_columns` to automatically build the search database:\n\n``` python\nimport svetoviz as sv\nfrom datasets import load_dataset\n\nhf_name = \"eltorio/ROCOv2-radiology\"\ndataset = load_dataset(hf_name, split=\"train\")\n\nlayout = sv.DatasetView(\n    id=hf_name,\n    dataset=dataset,\n    image_columns=[\"image\"],\n    info_columns=[\"image_id\", \"caption\", \"cui\"],\n    cell_width=400,\n    cell_height=400\n)\n\nsv.save_to_disk(\n    view=layout,\n    compression=\"png_0\",\n    directory=output_directory\n)\nsv.load_from_disk(directory=output_directory)\n```\n\nUse the web interface to search over the entire dataset:\n\nYou can also explore datasets already published online at [https://app.svetoviz.com](https://app.svetoviz.com).\n\nThe selected compression type dictates the following parameters of the final scene:\n\n- **Quality of the final scene**\n- **Total disk usage of the final scene**\n- **Total build time of the scene**\n\n**PNG compression levels**\n\n| Available constants | \n|---|\n| `PNG_0` (Highest Quality) | \n| `PNG_1` | \n| `PNG_2` | \n| `PNG_3` | \n| `PNG_4` | \n| `PNG_5` | \n| `PNG_6` | \n| `PNG_7` | \n| `PNG_8` | \n| `PNG_9` (Lowest Quality) | \n\n**JPEG compression levels**\n\n| Available constants | \n|---|\n| `JPEG_0` (Highest Quality) | \n| `JPEG_1` | \n| `JPEG_2` | \n| `JPEG_3` | \n| `JPEG_4` | \n| `JPEG_5` | \n| `JPEG_6` | \n| `JPEG_7` | \n| `JPEG_8` | \n| `JPEG_9` (Lowest Quality) | \n\nThe Views API provides a declarative way to organize multiple data sources into a single 3D scene. By using Layout containers, you can create structured environments for comparative analysis and large-scale dataset inspection.\n\nThe Views API is built on two primary class types: `View` and `Layout`.\n\n- **Views** represent individual data points, encapsulating various formats such as NumPy arrays, images, or other specialized data structures.\n- **Layouts** organize collections of views into structured 3D scenes by defining spatial relationships, such as line arrangements or grids. Layouts are inherently composable, allowing you to nest them within one another to build complex, multi-tiered visual environments.\n\n``` python\nimport svetoviz as sv\n\nview = sv.NumpyView(\n        id=\"numpy_view_example\",\n        data=np.random.rand(4, 4, 32, 32).astype(np.float32),\n        gap_size=10)\n\nsv.view(view=view)\npython\nimport svetoviz as sv\n\nimage = Image.open(BytesIO(requests.get(IMAGE_URL).content))\ndata = np.array(image)\nview = sv.NumpyView(\n        id=\"numpy_image_channels\",\n        data=data,\n        gap_size=10,\n        ordering=(2, 0, 1))\n\nsv.view(view=view)\n```\n\n| Raw array projection | Transposed mapping | \n|---|---|\n\nFor images, use `DiskImageView` to stream assets directly from storage, or `LazyImageView` to lazy-load images into RAM only when required. Both classes accept a URL, a local file path, or a PIL image object as the source.\n\n``` python\nimport svetoviz as sv\n\nview = sv.DiskImageView(\n        id=\"disc_image\",\n        image=IMAGE_URL)\n\n# or\n\nview = sv.LazyImageView(\n        id=\"lazy_image\",\n        image=IMAGE_URL)\n\nsv.view(view=view)\n```\n\nThe `DirectoryGridView` is a specialized layout class designed to automatically load and organize an entire directory of images into a structured grid scene.\n\n``` python\nimport svetoviz as sv\n\n# Optional function to provide searchable description per filepath\ndef description_func(filepath):\n    return f\"My description for {filepath}\"\n\nlayout = sv.DirectoryGridView(\n    id=\"directory_grid_example\",\n    directory=directory,\n    limit=100,\n    lazy=False,\n    description_func=description_func\n)\n\nsv.view(layout)\n```\n\n| Grid overview | Grid spread | \n|---|---|\n\nThe `DirectorySpiralView` is a specialized layout class designed to automatically load and organize an entire directory of images into a structured spiral scene.\n\n``` python\nimport svetoviz as sv\n\n# Optional function to provide searchable description per filepath\ndef description_func(filepath):\n    return f\"My description for {filepath}\"\n\nlayout = sv.DirectorySpiralView(\n    id=\"directory_spiral_view\",\n    directory=directory,\n    limit=100,\n    lazy=False,\n    description_func=description_func\n)\n\nsv.view(layout)\n```\n\n| Spiral overview | Spiral spread | \n|---|---|\n\n**Lazy vs eager loading**\n\n- `lazy=True` is limited by available RAM, and the scene may appear empty at launch until data loads.\n- `lazy=False` is limited by available disc space for the`DiskImageView` memory files and by the maximum number of open file descriptors.\n- `sv.view()` may start failing around 500 - 1000 data points. For larger collections, build the scene offline (see[Offline scene building](#offline-scene-building) ).\n\nThe `DatasetView` enables the integration of Hugging Face datasets directly into your scene. It automatically processes a dataset object and renders its entries into a structured grid of images. You will learn more about `DatasetView` in [Datasets](#6-datasets).\n\n``` python\nimport svetoviz as sv\n\nhf_name = \"Dewa/Dog_Emotion_Dataset_v2\"\ndataset = load_dataset(hf_name, split=\"train\")\nsubset = dataset.select(range(100))\n\nlayout = sv.DatasetView(\n    id=hf_name,\n    dataset=subset,\n    info_columns=[\"emotion\"],\n    image_columns=[\"image\"],\n    cell_width=400,\n    cell_height=400\n)\n\nsv.view(layout)\n```\n\nThe `VerticalLayout` arranges its child views in a linear vertical stack.\n\n``` python\nimport svetoviz as sv\nnumpy_array = np.random.rand(4, 4, 32, 32).astype(np.float32)\nimage = Image.open(BytesIO(requests.get(IMAGE_URL).content))\nimage_array = np.array(image)\n\nlayout = sv.VerticalLayout(\n    id=\"vertical_layout_example\",\n    views=[\n        sv.NumpyView(\n            id=\"array\",\n            data=numpy_array,\n            gap_size=10,\n            ordering=None),\n        sv.NumpyView(\n            id=\"image_array\",\n            data=image_array,\n            gap_size=10,\n            ordering=(2, 0, 1)),\n        sv.DiskImageView(\n            id=\"disc_image\",\n            image=image),\n        sv.LazyImageView(\n            id=\"lazy_image\",\n            image=image)\n        ],\n    )\n\nsv.view(layout)\n```\n\nThe `HorizontalLayout` arranges its child views in a linear horizontal stack.\n\n``` python\nimport svetoviz as sv\n\nnumpy_array = np.random.rand(4, 4, 32, 32).astype(np.float32)\nimage = Image.open(BytesIO(requests.get(IMAGE_URL).content))\nimage_array = np.array(image)\n\nlayout = sv.HorizontalLayout(\n    id=\"layout\",\n    title=\"Horizontal layout\",\n    views=[\n        sv.NumpyView(\n            id=\"array\",\n            data=numpy_array,\n            gap_size=10),\n        sv.NumpyView(\n            id=\"image_array\",\n            data=image_array,\n            gap_size=10,\n            ordering=(2, 0, 1)),\n        sv.DiskImageView(\n            id=\"disc_image\",\n            image=image),\n        sv.LazyImageView(\n            id=\"lazy_image\",\n            image=image)\n    ],\n)\n\nsv.view(layout)\n```\n\nThe `GridLayout` arranges its child views in a grid.\n\n``` python\nimport svetoviz as sv\n\ndirectory = \"downloaded_images\"\nimage_sources = []\nfor root, dirs, files in os.walk(directory):\n    for file in files:\n        image_sources.append(os.path.join(root, file))\n\nimage_views = [\n    sv.DiskImageView(id=f\"img_{i}\", image=src)\n    # or sv.LazyImageView(id=f\"img_{i}\", image=src)\n    for i, src in enumerate(image_sources)\n]\n\ngrid = sv.GridLayout(id=\"grid_layout_example\", views=image_views)\nsv.view(grid)\n```\n\nLayouts can be nested to create complex, multi-tiered scenes. Each layout object accepts an optional `title` argument; when provided, the title is rendered as an additional child at the beginning of the collection, adhering to the parent's defined spatial positioning.\n\n``` python\nimport svetoviz as sv\n\ndisc_image = sv.DiskImageView(\n    id=\"disc_image\",\n    image=\"sample_image.jpg\")\n\nlazy_image = sv.LazyImageView(\n    id=\"lazy_image\",\n    image=\"sample_image.jpg\")\n\narray = sv.NumpyView(\n    id=\"array\",\n    data=np.random.rand(4, 32, 4, 245, 245).astype(np.float32),\n    gap_size=10)\n\nimages_directory = \"downloaded_images\"\n\ndir_spiral_view = sv.DirectorySpiralView(\n    id=\"dir_spiral\",\n    directory=images_directory,\n    limit=100,\n    lazy=False\n)\ndir_grid_view = sv.DirectoryGridView(\n    id=\"dir_grid\",\n    directory=images_directory,\n    limit=100,\n    lazy=False\n)\n\nhf_name = \"Dewa/Dog_Emotion_Dataset_v2\"\ndataset = load_dataset(hf_name, split=\"train\")\nsubset = dataset.select(range(500))\nsubset2 = dataset.select(range(500, 1000))\n\nsubset_view_1 = sv.DatasetView(\n    id=\"subset1\",\n    dataset=subset,\n    image_columns=[\"image\"],\n    info_columns=[\"emotion\"],\n    cell_width=400,\n    cell_height=400\n)\nsubset_view_2 = sv.DatasetView(\n    id=\"subset2\",\n    dataset=subset2,\n    image_columns=[\"image\"],\n    info_columns=[\"emotion\"],\n    cell_width=400,\n    cell_height=400\n)\n\narray_container = sv.VerticalLayout(\n    id=\"Numpy\",\n    title=\"Numpy\",\n    views=[array])\nimage_container = sv.VerticalLayout(\n    id=\"Image\",\n    title=\"Images\",\n    views=[disc_image, lazy_image])\ndirectory_grid_container = sv.VerticalLayout(\n    id=\"directory_grid_id\",\n    title=\"Directory grid view\",\n    views=[dir_grid_view])\ndirectory_spiral_container = sv.VerticalLayout(\n    id=\"directory_spiral_id\",\n    title=\"Directory spiral view\",\n    views=[dir_spiral_view])\nsubset_1_container = sv.VerticalLayout(\n    id=\"dataset_subset_1\",\n    title=\"Subset 1\",\n    views=[subset_view_1])\nsubset_2_container = sv.VerticalLayout(\n    id=\"dataset_subset_2\",\n    title=\"Subset 2\",\n    views=[subset_view_2])\n\nlayout = sv.GridLayout(\n        id=\"parent_layout\",\n        views=[\n            image_container,\n            array_container,\n            directory_grid_container,\n            directory_spiral_container,\n            subset_1_container,\n            subset_2_container]\n    )\n\nsv.view(layout)\n```\n\nYou can switch between different layout types at any time directly through the web interface. Additionally, you can dynamically modify properties such as spacing, padding, and spread to refine the spatial organization of your scene.\n\n| Horizontal spread | Vertical spread | \n|---|---|\n\nDisplaying a scene with `view` is typically sufficient for scenes containing a small number of data points. For large-scale scenes, build your scene offline. Once the scene is built, you can launch it directly from the directory without requiring access to the original source data.\n\nThis example demonstrates building a unified scene from the complete **ESA/Hubble** and **ESA/Webb** image catalogs in maximum quality.\n\n``` python\nimport svetoviz as sv\n\nimages_directory = \"/Users/piotrgryko/Desktop/nasaimages\"\nconfig_file_path = os.path.join(images_directory, \"config.json\")\n\nscraped_data = {}\nwith open(config_file_path, \"r\", encoding=\"utf-8\") as f:\n    scraped_data = json.load(f)\n\ndef description_func(filepath):\n    filename = os.path.basename(filepath)\n    name_without_ext = os.path.splitext(filename)[0]\n    metadata = scraped_data.get(name_without_ext, {})\n    lines = []\n    for key, value in metadata.items():\n        lines.append(f\"{key}: {value}\")\n    return \"\\n\\n\".join(lines)\n\nlayout = sv.DirectorySpiralView(\n    id=\"Galaxy\",\n    directory=images_directory,\n    lazy=True,\n    description_func=description_func\n)\n\n# Export to persistent storage\nsv.save_to_disk(\n    view=layout,\n    threaded=True,\n    directory=\"output/space_scene\",\n    compression=\"jpeg_0\"\n)\n```\n\nOnce the build is complete, launch the interactive 3D environment directly from the directory:\n\n``` python\nimport svetoviz as sv\n\nsv.load_from_disk(directory=\"output/space_scene\")\n```\n\nAlternatively, you can process the scene further and generate a PMTiles file for remote hosting and streaming:\n\n``` python\nimport svetoviz as sv\n\n# Create PMTiles file inside the scene directory\nsv.build_pmtiles_file(\n    directory=\"output/space_scene\"\n)\n```\n\nAfter uploading the generated PMTiles file to a remote server, you can browse the scene from anywhere without distributing the original dataset:\n\n``` python\nimport svetoviz as sv\n\ndb_file = \"output/space_scene/tree.db\"\nurl = \"your remote pmtiles file url\"\n\nlayout = sv.RemotePmTilesLayout(\n    id=\"universe\",\n    pm_tiles_url=url,\n    tree_db_file=db_file\n)\n\nsv.view(layout)\n```\n\nTo re-open a saved scene as a widget instead of launching it, use `DiskSceneView`:\n\n``` python\nimport svetoviz as sv\n\n# Saved Dog_Emotion_Dataset_v2 dataset\nview = sv.DiskSceneView(\n    id=\"dog_emotions\",\n    directory=\"output/dog_emotion_dataset\"\n)\n\n# Saved ROCOv2-radiology dataset\nview2 = sv.DiskSceneView(\n    id=\"roco_radiology\",\n    directory=\"output/roco_scene\"\n)\n\nlayout = sv.VerticalLayout(id=\"scenes\", views=[view, view2])\nsv.view(layout)\n```\n\nSvetoviz supports `torch.Tensor` visualization exactly like standard NumPy arrays.\n\nUse `tensor()` to project a single `torch.Tensor` into the 3D scene. The `gap_size` parameter controls the visual spacing between high-dimensional slices.\n\n``` python\nimport svetoviz as sv\n\ndata = torch.rand((4, 4, 256, 256), dtype=torch.float32)\nsv.tensor(data, gap_size=10)\n```\n\nSvetoviz supports the full spectrum of torch dtypes - from standard integers and floats to complex numbers and booleans. Using `tensors()`, you can pass a list of `torch.Tensor` with varying shapes and types.\n\n``` python\nimport svetoviz as sv\n\nsv.tensors([\n    # integers\n    torch.randint(0, 2, (2, 72, 72), dtype=torch.bool),\n    torch.randint(np.iinfo(np.int8).min, np.iinfo(np.int8).max, (2, 60, 60), dtype=torch.int8),\n    torch.randint(np.iinfo(np.int16).min, np.iinfo(np.int16).max, (4, 8, 16, 16), dtype=torch.int16),\n    torch.randint(np.iinfo(np.int32).min, np.iinfo(np.int32).max, (4, 4, 64, 64), dtype=torch.int32),\n    torch.randint(np.iinfo(np.int64).min, np.iinfo(np.int64).max, (4, 2, 32, 64), dtype=torch.int64),\n    torch.randint(np.iinfo(np.uint8).min, np.iinfo(np.uint8).max, (2, 3, 128, 128), dtype=torch.uint8),\n    torch.randint(np.iinfo(np.uint16).min, np.iinfo(np.uint16).max, (16, 128, 128), dtype=torch.uint16),\n    torch.randint(np.iinfo(np.uint32).min, np.iinfo(np.uint32).max, (4, 4, 64, 64), dtype=torch.uint32),\n    torch.frombuffer(np.random.bytes(4 * 2 * 32 * 64 * 8), dtype=torch.uint64).reshape(4, 2, 32, 64),\n\n    # floats\n    (torch.rand(256, 256, dtype=torch.float32) * torch.finfo(torch.float16).max).to(torch.float16),\n    (torch.rand(256, 256, dtype=torch.float32) * torch.finfo(torch.bfloat16).max).to(torch.bfloat16),\n    (torch.rand(256, 256, dtype=torch.float32) * torch.finfo(torch.float32).max).to(torch.float32),\n    (torch.rand(256, 256, dtype=torch.float64) * torch.finfo(torch.float64).max).to(torch.float64),\n\n    # complex numbers\n    torch.complex(\n        torch.rand(32, 32),\n        torch.rand(32, 32)).to(torch.complex32) * torch.finfo(torch.complex32).max,\n    torch.complex(\n        torch.rand(32, 32),\n        torch.rand(32, 32)).to(torch.complex64) * torch.finfo(torch.complex64).max,\n    torch.complex(\n        torch.rand(32, 32),\n        torch.rand(32, 32)).to(torch.complex128) * torch.finfo(torch.complex128).max\n], gap_size=32)\n```\n\n`torch.Tensor` visualization inherits all features from standard NumPy views, including stacking, ordering, colormaps, and large tensor support. `TensorView` is also the primary view used for rendering PyTorch models.\n\n``` python\nimport svetoviz as sv\n\nview = sv.TensorView(\n        id=\"tensor_view_example\",\n        data=torch.rand((4, 4, 256, 256), dtype=torch.float32),\n        gap_size=10)\n\nsv.view(view=view)\n```\n\nSvetoviz provides two primary methods for attaching the debugger to your models.\n\n``` python\n@classmethod\ndef model(cls,\n    id,\n    model,\n    tokenizer=None,\n    image_processor=None,\n    video_processor=None,\n    processor=None,\n    scheduler=None,\n    feature_extractor=None,\n    terminal_callback=None,\n    blocking=True\n)\npython\n@classmethod\ndef pipeline(cls,\n    id,\n    pipe,\n    terminal_callback=None,\n    blocking=True\n)\n```\n\nTo interact with the model, use the `terminal_callback` function to send data directly from the GUI, or use the `blocking=False` argument (WebGPU only) to attach the debugger in non-blocking mode and continue your standard interaction loop.\n\nSelected breakpoints flash during interaction, and their activations are automatically collected. Afterward, you can visually inspect the input and output data alongside their relation to the module.\n\n``` python\nimport svetoviz as sv\n\ntokenizer = GPT2Tokenizer.from_pretrained('gpt2', device_map=\"cpu\")\nmodel = GPT2LMHeadModel.from_pretrained('gpt2', device_map=\"cpu\")\n\ndef terminal_callback(buffer, message, images, files):\n    # message, images and files come from GUI terminal input\n    inputs = tokenizer(message, return_tensors=\"pt\")\n\n    # Generate continuation\n    outputs = model.generate(**inputs, max_new_tokens=50)\n\n    # Decode to string\n    decoded = tokenizer.decode(outputs[0], skip_special_tokens=True)\n\n    # Send messages back to GUI\n    buffer.send_user_message(message)\n    buffer.send_system_message(decoded)\n\nsv.model(\n    id=\"GPT2\",\n    model=model,\n    tokenizer=tokenizer,\n    terminal_callback=terminal_callback\n)\n```\n\n| GPT-2 architecture | GPT tokenizer | \n|---|---|\n\n``` python\nimport svetoviz as sv\n\nimage_processor = DetrImageProcessor.from_pretrained(\n    \"facebook/detr-resnet-50\",\n    revision=\"no_timm\",\n    device_map=\"cpu\")\nmodel = DetrForObjectDetection.from_pretrained(\n    \"facebook/detr-resnet-50\",\n    revision=\"no_timm\",\n    device_map=\"cpu\")\n\ndef terminal_callback(buffer, message, images, files):\n    # images is an PIL.Image array of images added to terminal GUI\n    for image in images:\n        inputs = image_processor(images=image, return_tensors=\"pt\")\n        outputs = model(**inputs)\n        buffer.send_system_message(\"processed\")\n\nsv.model(\n    id=\"DERT\",\n    model=model,\n    image_processor=image_processor,\n    terminal_callback=terminal_callback\n)\n```\n\n| DETR Conv2d | DETR kernel | \n|---|---|\n\n| YOLOS Conv2d | YOLOS linear | \n|---|---|\n\nThe `blocking=False` argument starts the debugger in non-blocking mode, allowing you to continue with your model interaction as usual.\n\n``` python\nimport svetoviz as sv\n\ntokenizer = AutoTokenizer.from_pretrained(\n    \"speakleash/Bielik-Minitron-7B-v3.0-Instruct\")\nmodel = AutoModelForCausalLM.from_pretrained(\n    \"speakleash/Bielik-Minitron-7B-v3.0-Instruct\",\n    torch_dtype=torch.float16)\n\nsv.model(\n    id=\"Bielik-Minitron-7B\",\n    model=model,\n    tokenizer=tokenizer,\n    blocking=False\n)\n\nwhile True:\n    # Debugger is attached. You can interact or inspect training loop\n    text = my_external_input_message()\n\n    inputs = tokenizer(text, return_tensors=\"pt\")\n    outputs = model.generate(**inputs, max_new_tokens=50)\n```\n\nCollected activations are stored in RAM. For small models, you can inspect an entire pass. For larger models like diffusion models, select specific breakpoints. For example, you can select the Scheduler module to see each step of the denoising process.\n\n``` python\nimport svetoviz as sv\n\npipe = DiffusionPipeline.from_pretrained(\n    \"stable-diffusion-v1-5/stable-diffusion-v1-5\",\n    torch_dtype=torch.float16)\n\npipe = pipe.to(\"mps\")\npipe.enable_attention_slicing()\n\ndef terminal_callback(buffer, message, images, files):\n    # Generate an image from terminal input message\n    buffer.send_system_message(message)\n    image = pipe(message).images[0]\n    image.show(\"output.png\")\n\nsv.pipeline(\n    id=\"stable-diffusion-v1-5\",\n    pipe=pipe,\n    terminal_callback=terminal_callback\n)\n```\n\n| stable-diffusion-1-5 structure | stable-diffusion-1-5 activation | \n|---|---|\n\nUse the Views API with `ModelView` or `PipelineView` to build a compressed, static representation of the model:\n\n``` python\nimport svetoviz as sv\n\nview = sv.ModelView(\n    id=\"detr-resnet-50\",\n    model=model,\n    image_processor=image_processor\n)\n\nsv.save_to_disk(view=view, directory=\"output/detr_scene\")\n```\n\nUse the settings window to modify various rendering aspects of your scene. Adjust themes, layouts, or matrix settings to control the visual representation of data values when viewed at close range (`WebConfig.matrix_mode`: `quads`, `cubes`, `diamonds`, `spheres`).\n\nOnline models are browsable at [https://www.svetoviz.com](https://www.svetoviz.com).\n\nThe `svetoviz` Python package is the entry point for the whole application. Every helper builds a scene in your Python process and streams it to the WebGPU renderer, which opens automatically in your browser at `http://localhost:8000`. There is no separate native binary to install - the renderer ships with the package and runs locally.\n\nDownload [`examples/quickstart_webgpu.py`](https://github.com/PiotrGryko/svetoviz/blob/main/examples/quickstart_webgpu.py) for a complete, runnable script.\n\nEvery data type is reached through the same set of class methods, so moving between arrays, images, tensors and models only changes the function you call:\n\n| Call | Purpose | \n|---|---|\n| `sv.array(np_array, gap_size=0, ordering=None)` | Visualize a single NumPy array | \n| `sv.arrays(arrays, gap_size=0)` | Visualize a list of NumPy arrays | \n| `sv.tensor(tensor, gap_size=0, ordering=None)` | Visualize a single `torch.Tensor` | \n| `sv.tensors(tensors, gap_size=0)` | Visualize a list of tensors | \n| `sv.image(image)` | Visualize one image (URL / path / PIL) | \n| `sv.images(images)` | Visualize a list of images | \n| `sv.pytorch(module, terminal_callback=None)` | Attach the debugger to a `nn.Module` | \n| `sv.model(id, model, ...)` | Attach the debugger to a Hugging Face model | \n| `sv.pipeline(id, pipe, ...)` | Attach the debugger to a pipeline | \n| `sv.view(view)` | Open a View or Layout instance | \n| `sv.save_to_disk(view, directory, ...)` | Build a scene offline | \n| `sv.load_from_disk(directory)` | Open a previously built scene | \n\nAssemble a scene from Views and Layouts and control the spatial organization with `padding`, `spacing` and `gravity`. These arguments are available on every layout container, so the same code produces a consistent scene whether it is opened live or built offline.\n\n``` python\nimport svetoviz as sv\nimport numpy as np\n\nview = sv.GridLayout(\n    id=\"layout\",\n    title=\"Grid Layout\",\n    padding=\"2%\",\n    title_color=(155, 155, 155),\n    background_color=(0, 0, 0, 255),\n    spacing=40,\n    views=[\n        sv.VerticalLayout(\n            id=\"vertical1\",\n            title=\"np.float32\",\n            padding=\"5%\",\n            spacing=\"5%\",\n            background_color=(50, 50, 50, 255),\n            views=[\n                sv.NumpyView(\n                    id=\"float32\",\n                    data=np.random.rand(6, 24, 128, 32).astype(np.float32),\n                    gap_size=10,\n                    ordering=None)\n            ]\n        ),\n        sv.VerticalLayout(\n            id=\"vertical2\",\n            title=\"Images\",\n            padding=\"5%\",\n            spacing=\"5%\",\n            background_color=(50, 50, 50, 255),\n            views=[\n                sv.DiskImageView(\n                    id=\"disk_image\",\n                    image=IMAGE_URL),\n                sv.LazyImageView(\n                    id=\"lazy_image\",\n                    image=IMAGE_URL)\n            ]\n        ),\n    ],\n)\n\nsv.view(view=view)\n```\n\nDirectory views load and organize an entire folder of images into a structured scene:\n\n``` python\nimport svetoviz as sv\n\nview = sv.DirectorySpiralView(\n    directory=\"downloaded_images\",\n    limit=200,\n    lazy=False\n)\nsv.view(view)\n```\n\nBuild a scene once and reopen it later without the original data. `save_to_disk()` writes tiles plus a `tree.db`, and `load_from_disk()` opens it again:\n\n``` python\nimport svetoviz as sv\n\nsv.save_to_disk(view=view, directory=\"output/scene\")\n\nsv.load_from_disk(directory=\"output/scene\")\n```\n\nSvetoviz provides native support for PyTorch modules. Your interaction activations are collected and presented on the screen, allowing for real-time inspection of data transformations.\n\n**114 documented modules** are supported: 73 module pages plus 28 activation functions and 13 loss functions. Every module is traced through the same pipeline: input -> weights -> output, with the exact relation between a selected output value and the input values that produced it.\n\nThe three views below show that pipeline on `nn.Conv3d`. First the input volume is convolved by the learned kernel, producing a stack of spatial feature maps. Then each output value can be traced back to the exact input positions and kernel weights that produced it. Finally, the weights, bias, input and output tensors are inspected side by side for the selected value.\n\n`nn.Conv3d` feature maps - the input volume convolved with the learned kernel produces one spatial feature map per output channel.\n\n`nn.Conv3d` value mapping - a selected output value is traced back to the input patch and the kernel weights that produced it.\n\n`nn.Conv3d` bias and weight inspection - weights, bias, input and output tensors are shown side by side for the selected value.\n\nThe `pytorch` interface wraps your `nn.Module` and provides a terminal for live interaction. This allows you to process data and inspect the resulting tensors without leaving the visualization environment.\n\n``` python\nimport svetoviz as sv\nimport torch\nimport torch.nn as nn\nfrom PIL import Image\n\n# Prepare data\nurl = \"https://cdn.freecodecamp.org/curriculum/cat-photo-app/relaxing-cat.jpg\"\nimg = Image.open(requests.get(url, stream=True).raw).resize((64, 64))\nimg_np = np.array(img).transpose(2, 0, 1)\nimage_data = torch.from_numpy(img_np).float().unsqueeze(0)\n\n# Your pytorch module\nconv = nn.Conv2d(3, 4, 5, padding=10)\n\ndef terminal_callback(buffer, message, images, files):\n    # Interact with the module as you normally do\n    conv(image_data)\n    buffer.send_system_message(\"processed\")\n\n# Start the session\nsv.pytorch(module=conv, terminal_callback=terminal_callback)\n```\n\nYou can hover or click on output values to see the mappings and relations between layers. Svetoviz provides a visual explanation of the provenance for each value in the tensor.\n\nFor example, you can find the exact kernel position for convolutions, or visualize the column-to-patch mapping for operations like `fold` and `unfold`. Clicking an output value reveals the input-to-output spatial relationship.\n\nEach table lists the module, a one-line purpose and the parameters that matter most when inspecting it. The tables follow the documentation category order: convolution, pooling, padding, normalization, linear and embedding, dropout, shape and view, then activation functions, and loss functions last. Every module links to its illustrated guide on [https://pytorch.svetoviz.com](https://pytorch.svetoviz.com).\n\n| Module | Purpose | Key parameters | \n|---|---|---|\n| `nn.Conv1d` | 1-D convolution over signals `(N, C, L)` | `in_channels` ,`out_channels` ,`kernel_size` ,`stride` ,`padding` ,`dilation` ,`groups` | \n| `nn.ConvTranspose1d` | Transposed 1-D convolution (learned upsampling) | `in_channels` ,`out_channels` ,`kernel_size` ,`stride` ,`padding` ,`output_padding` | \n| `nn.Conv2d` | 2-D convolution over images `(N, C, H, W)` | `in_channels` ,`out_channels` ,`kernel_size` ,`stride` ,`padding` ,`groups` | \n| `nn.ConvTranspose2d` | Transposed 2-D convolution (decoders, GANs) | `in_channels` ,`out_channels` ,`kernel_size` ,`stride` ,`padding` ,`output_padding` | \n| `nn.Conv3d` | 3-D convolution over volumes `(N, C, D, H, W)` | `in_channels` ,`out_channels` ,`kernel_size` ,`stride` ,`padding` | \n| `nn.ConvTranspose3d` | Transposed 3-D convolution | `in_channels` ,`out_channels` ,`kernel_size` ,`stride` ,`padding` | \n\n| Module | Purpose | Key parameters | \n|---|---|---|\n| `nn.MaxPool1d` | Max pooling over 1-D signals | `kernel_size` ,`stride` ,`padding` ,`dilation` ,`return_indices` | \n| `nn.MaxPool2d` | Max pooling over 2-D feature maps | `kernel_size` ,`stride` ,`padding` ,`return_indices` | \n| `nn.MaxPool3d` | Max pooling over 3-D volumes | `kernel_size` ,`stride` ,`padding` ,`return_indices` | \n| `nn.MaxUnpool1d` | Inverse of `MaxPool1d` using stored indices | `kernel_size` ,`stride` ,`padding` | \n| `nn.MaxUnpool2d` | Inverse of `MaxPool2d` using stored indices | `kernel_size` ,`stride` ,`padding` | \n| `nn.MaxUnpool3d` | Inverse of `MaxPool3d` using stored indices | `kernel_size` ,`stride` ,`padding` | \n| `nn.AvgPool1d` | Average pooling over 1-D signals | `kernel_size` ,`stride` ,`padding` ,`count_include_pad` | \n| `nn.AvgPool2d` | Average pooling over 2-D feature maps | `kernel_size` ,`stride` ,`padding` ,`count_include_pad` | \n| `nn.AvgPool3d` | Average pooling over 3-D volumes | `kernel_size` ,`stride` ,`padding` ,`count_include_pad` | \n| `nn.LPPool1d` | Lp-norm pooling over 1-D signals | `norm_type` ,`kernel_size` ,`stride` | \n| `nn.LPPool2d` | Lp-norm pooling over 2-D feature maps | `norm_type` ,`kernel_size` ,`stride` | \n| `nn.LPPool3d` | Lp-norm pooling over 3-D volumes | `norm_type` ,`kernel_size` ,`stride` | \n| `nn.AdaptiveMaxPool1d` | Max pool to a fixed output length | `output_size` ,`return_indices` | \n| `nn.AdaptiveMaxPool2d` | Max pool to a fixed output grid | `output_size` ,`return_indices` | \n| `nn.AdaptiveMaxPool3d` | Max pool to a fixed output volume | `output_size` ,`return_indices` | \n| `nn.AdaptiveAvgPool1d` | Average pool to a fixed output length | `output_size` | \n| `nn.AdaptiveAvgPool2d` | Average pool to a fixed output grid | `output_size` | \n| `nn.AdaptiveAvgPool3d` | Average pool to a fixed output volume | `output_size` | \n| `nn.FractionalMaxPool2d` | Random-step max pooling with fractional coverage | `kernel_size` ,`output_ratio` /`output_size` | \n| `nn.FractionalMaxPool3d` | 3-D fractional max pooling | `kernel_size` ,`output_ratio` /`output_size` | \n\n| Module | Purpose | Key parameters | \n|---|---|---|\n| `nn.ReflectionPad1d` | Reflects the signal at the border (1-D) | `padding` | \n| `nn.ReflectionPad2d` | Reflects the image at the border (2-D) | `padding` | \n| `nn.ReflectionPad3d` | Reflects the volume at the border (3-D) | `padding` | \n| `nn.ReplicationPad1d` | Repeats edge values (1-D) | `padding` | \n| `nn.ReplicationPad2d` | Repeats edge values (2-D) | `padding` | \n| `nn.ReplicationPad3d` | Repeats edge values (3-D) | `padding` | \n| `nn.ZeroPad1d` | Zero padding (1-D) | `padding` | \n| `nn.ZeroPad2d` | Zero padding (2-D) | `padding` | \n| `nn.ZeroPad3d` | Zero padding (3-D) | `padding` | \n| `nn.ConstantPad1d` | Constant-value padding (1-D) | `padding` ,`value` | \n| `nn.ConstantPad2d` | Constant-value padding (2-D) | `padding` ,`value` | \n| `nn.ConstantPad3d` | Constant-value padding (3-D) | `padding` ,`value` | \n| `nn.CircularPad1d` | Wraps the signal around (1-D) | `padding` | \n| `nn.CircularPad2d` | Wraps the image around (2-D) | `padding` | \n| `nn.CircularPad3d` | Wraps the volume around (3-D) | `padding` | \n\n| Module | Purpose | Key parameters | \n|---|---|---|\n| `nn.BatchNorm1d` | Normalizes per channel across a batch (1-D) | `num_features` ,`eps` ,`momentum` ,`affine` ,`track_running_stats` | \n| `nn.BatchNorm2d` | Normalizes per channel across a batch (2-D) | `num_features` ,`eps` ,`momentum` ,`affine` | \n| `nn.BatchNorm3d` | Normalizes per channel across a batch (3-D) | `num_features` ,`eps` ,`momentum` ,`affine` | \n| `nn.InstanceNorm1d` | Normalizes each sample independently (1-D) | `num_features` ,`eps` ,`momentum` ,`affine` ,`track_running_stats` | \n| `nn.InstanceNorm2d` | Normalizes each sample independently (2-D) | `num_features` ,`eps` ,`momentum` ,`affine` | \n| `nn.InstanceNorm3d` | Normalizes each sample independently (3-D) | `num_features` ,`eps` ,`momentum` ,`affine` | \n| `nn.LayerNorm` | Normalizes over the trailing normalized shape | `normalized_shape` ,`eps` ,`elementwise_affine` | \n| `nn.GroupNorm` | Splits channels into groups and normalizes each | `num_groups` ,`num_channels` ,`eps` ,`affine` | \n| `nn.LocalResponseNorm` | Lateral inhibition across neighbouring channels | `size` ,`alpha` ,`beta` ,`k` | \n\n| Module | Purpose | Key parameters | \n|---|---|---|\n| `nn.Linear` | Fully connected transform `y = xA^T + b` | `in_features` ,`out_features` ,`bias` | \n| `nn.Bilinear` | Bilinear combination of two inputs | `in1_features` ,`in2_features` ,`out_features` ,`bias` | \n| `nn.Embedding` | Lookup table mapping indices to vectors | `num_embeddings` ,`embedding_dim` ,`padding_idx` ,`max_norm` | \n| `nn.EmbeddingBag` | Embedding lookup with on-the-fly reduction | `num_embeddings` ,`embedding_dim` ,`mode` (`mean` /`sum` /`max` ) | \n| `nn.CosineSimilarity` | Cosine similarity along a dimension | `dim` ,`eps` | \n| `nn.PairwiseDistance` | p-norm distance between two batches | `p` ,`eps` ,`keepdim` | \n\n| Module | Purpose | Key parameters | \n|---|---|---|\n| `nn.Dropout` | Randomly zeroes elements during training | `p` ,`inplace` | \n| `nn.Dropout1d` | Drops entire 1-D channels | `p` ,`inplace` | \n| `nn.Dropout2d` | Drops entire feature maps | `p` ,`inplace` | \n| `nn.Dropout3d` | Drops entire volumetric channels | `p` ,`inplace` | \n| `nn.AlphaDropout` | Self-normalizing dropout for SELU networks | `p` ,`inplace` | \n| `nn.FeatureAlphaDropout` | Channel-wise AlphaDropout | `p` ,`inplace` | \n\n| Module | Purpose | Key parameters | \n|---|---|---|\n| `nn.Unfold` | Extracts sliding local blocks into columns | `kernel_size` ,`dilation` ,`padding` ,`stride` | \n| `nn.Fold` | Combines sliding local blocks back into a tensor | `output_size` ,`kernel_size` ,`dilation` ,`padding` ,`stride` | \n| `nn.Flatten` | Flattens a contiguous range of dimensions | `start_dim` ,`end_dim` | \n| `nn.Unflatten` | Expands one dimension into a shape | `dim` ,`unflattened_size` | \n| `nn.PixelShuffle` | Rearranges `(*, C*r^2, H, W)` into`(*, C, H*r, W*r)` | `upscale_factor` | \n| `nn.PixelUnshuffle` | Inverse rearrangement of `PixelShuffle` | `downscale_factor` | \n| `nn.Upsample` | Generic resampling of spatial dimensions | `size` /`scale_factor` ,`mode` ,`align_corners` | \n| `nn.UpsamplingNearest2d` | Nearest-neighbour upsampling, deprecated alias | `size` /`scale_factor` | \n| `nn.UpsamplingBilinear2d` | Bilinear upsampling, deprecated alias | `size` /`scale_factor` | \n| `nn.ChannelShuffle` | Interleaves channels between groups | `groups` | \n| `nn.Identity` | Pass-through, useful as a breakpoint placeholder | none | \n\n``` python\nimport svetoviz as sv\n\ndef demo_activation():\n    input_tensor = torch.from_numpy(img_np)\\\n        .view(1, 1, height, width)\\\n        .repeat(1, 2, 1, 1)\n\n    activations = nn.ModuleDict({\n        \"ReLU\": nn.ReLU(),\n        \"LeakyReLU\": nn.LeakyReLU(negative_slope=0.02),\n        \"PReLU\": nn.PReLU(num_parameters=2),\n        \"GELU\": nn.GELU(),\n        \"SiLU\": nn.SiLU(),\n        \"Mish\": nn.Mish(),\n        \"Hardswish\": nn.Hardswish(),\n        \"Sigmoid\": nn.Sigmoid(),\n        \"Tanh\": nn.Tanh(),\n        \"Softmax\": nn.Softmax(dim=1),\n        \"LogSoftmax\": nn.LogSoftmax(dim=-1),\n        \"ELU\": nn.ELU(),\n        \"SELU\": nn.SELU(),\n        \"Softplus\": nn.Softplus(),\n        \"Threshold\": nn.Threshold(threshold=0.1, value=-2.0),\n        \"Softshrink\": nn.Softshrink(lambd=0.5),\n        \"GLU\": nn.GLU(dim=1),\n        \"Hardshrink\": nn.Hardshrink(lambd=0.5),\n        \"Hardsigmoid\": nn.Hardsigmoid(),\n        \"Hardtanh\": nn.Hardtanh(min_val=-1.0, max_val=1.0),\n        \"LogSigmoid\": nn.LogSigmoid(),\n        \"ReLU6\": nn.ReLU6(),\n        \"RReLU\": nn.RReLU(),\n        \"CELU\": nn.CELU(),\n        \"Softsign\": nn.Softsign(),\n        \"Tanhshrink\": nn.Tanhshrink(),\n        \"Softmin\": nn.Softmin(dim=1),\n        \"Softmax2d\": nn.Softmax2d()\n    })\n\n    def terminal_callback(buffer, message, images, files):\n        for name, module in activations.items():\n            output = module(input_tensor)\n            buffer.send_system_message(f\"Applied {name}: Output shape {list(output.shape)}\")\n\n    sv.pytorch(module=activations, terminal_callback=terminal_callback)\n```\n\n| Module | Purpose | Key parameters | \n|---|---|---|\n| `nn.ReLU` | Half-wave rectifier, `max(0, x)` | `inplace` | \n| `nn.LeakyReLU` | ReLU with a small negative slope | `negative_slope` ,`inplace` | \n| `nn.PReLU` | ReLU with a learned negative slope | `num_parameters` ,`init` | \n| `nn.GELU` | Gaussian error linear unit | `approximate` (`none` /`tanh` ) | \n| `nn.SiLU` | Sigmoid-weighted linear unit (Swish) | `inplace` | \n| `nn.Mish` | Smooth non-monotonic activation | `inplace` | \n| `nn.Hardswish` | Piecewise-linear approximation of SiLU | `inplace` | \n| `nn.Sigmoid` | Logistic squashing to `(0, 1)` | none | \n| `nn.Tanh` | Hyperbolic tangent, zero-centred | none | \n| `nn.Softmax` | Normalizes values into a probability simplex | `dim` | \n| `nn.LogSoftmax` | Log of the softmax, numerically stable | `dim` | \n| `nn.Softmin` | Softmax over negated inputs | `dim` | \n| `nn.Softmax2d` | Softmax over each spatial location | none | \n| `nn.ELU` | Exponential linear unit | `alpha` ,`inplace` | \n| `nn.SELU` | Self-normalizing exponential unit | `inplace` | \n| `nn.CELU` | Continuously differentiable exponential unit | `alpha` ,`inplace` | \n| `nn.Softplus` | Smooth approximation of ReLU | `beta` ,`threshold` | \n| `nn.Softsign` | `x / (1 + abs(x))` , a smooth squashing curve | none | \n| `nn.Tanhshrink` | `x - tanh(x)` | none | \n| `nn.Threshold` | Hard threshold with a replacement value | `threshold` ,`value` | \n| `nn.Softshrink` | Soft thresholding, used in sparse coding | `lambd` | \n| `nn.Hardshrink` | Hard thresholding | `lambd` | \n| `nn.Hardsigmoid` | Piecewise-linear sigmoid | `inplace` | \n| `nn.Hardtanh` | Clamps values into a fixed interval | `min_val` ,`max_val` | \n| `nn.LogSigmoid` | Log of the sigmoid | none | \n| `nn.ReLU6` | ReLU capped at 6 | `inplace` | \n| `nn.RReLU` | Randomized leaky ReLU during training | `lower` ,`upper` ,`inplace` | \n| `nn.GLU` | Gated linear unit over a split dimension | `dim` | \n\n``` python\nimport svetoviz as sv\n\ndef demo_loss():\n    losses = nn.ModuleDict({\n        \"L1\": nn.L1Loss(),\n        \"MSE\": nn.MSELoss(),\n        \"SmoothL1\": nn.SmoothL1Loss(),\n        \"Huber\": nn.HuberLoss(delta=1.0),\n        \"CrossEntropy\": nn.CrossEntropyLoss(),\n        \"BCEWithLogits\": nn.BCEWithLogitsLoss(),\n        \"KLDiv\": nn.KLDivLoss(reduction=\"batchmean\"),\n        \"PoissonNLL\": nn.PoissonNLLLoss(),\n        \"MultiLabelSoftMargin\": nn.MultiLabelSoftMarginLoss(),\n        \"MarginRanking\": nn.MarginRankingLoss(margin=0.0),\n        \"CosineEmbedding\": nn.CosineEmbeddingLoss(margin=0.0),\n        \"TripletMargin\": nn.TripletMarginLoss(margin=1.0, p=2.0),\n        \"TripletMarginWithDistance\": nn.TripletMarginWithDistanceLoss()\n    })\n\n    def terminal_callback(buffer, message, images, files):\n        for name in losses:\n            buffer.send_system_message(f\"Loaded {name}\")\n\n    sv.pytorch(module=losses, terminal_callback=terminal_callback)\n```\n\n| Module | Purpose | Key parameters | \n|---|---|---|\n| `nn.L1Loss` | Mean absolute error | `reduction` | \n| `nn.MSELoss` | Mean squared error | `reduction` | \n| `nn.SmoothL1Loss` | Quadratic near zero, linear in the tails | `beta` ,`reduction` | \n| `nn.HuberLoss` | Huber combination of L1 and L2 | `delta` ,`reduction` | \n| `nn.CrossEntropyLoss` | Log-softmax followed by NLL for class logits | `weight` ,`ignore_index` ,`label_smoothing` | \n| `nn.BCEWithLogitsLoss` | Sigmoid plus binary cross entropy, numerically stable | `weight` ,`pos_weight` ,`reduction` | \n| `nn.KLDivLoss` | Kullback-Leibler divergence between distributions | `reduction` (`batchmean` for true KL) | \n| `nn.PoissonNLLLoss` | Negative log likelihood of a Poisson target | `log_input` ,`full` ,`eps` | \n| `nn.MultiLabelSoftMarginLoss` | One-vs-all logistic loss for multi-label targets | `weight` ,`reduction` | \n| `nn.MarginRankingLoss` | Ranking loss with a margin between pairs | `margin` ,`reduction` | \n| `nn.CosineEmbeddingLoss` | Cosine distance with a target label of `1` or`-1` | `margin` ,`reduction` | \n| `nn.TripletMarginLoss` | Anchor / positive / negative embedding separation | `margin` ,`p` ,`eps` ,`swap` | \n| `nn.TripletMarginWithDistanceLoss` | Triplet loss with a pluggable distance function | `distance_function` ,`margin` ,`swap` | \n\nBrowse every module screenshot and per-module walkthrough at **[https://pytorch.svetoviz.com](https://pytorch.svetoviz.com)**.\n\nEverything in this README runs in the live viewer. You do not need to install anything to look at the public scenes, module walkthroughs and published datasets.\n\n| Destination | What is there | \n|---|---|\n| **[https://www.svetoviz.com](https://www.svetoviz.com)** | Product overview, the public 3D scene directory and pricing | \n| **[https://www.svetoviz.com/docs](https://www.svetoviz.com/docs)** | The full manuals and guides mirrored by this README | \n| **[https://pytorch.svetoviz.com](https://pytorch.svetoviz.com)** | Illustrated per-module guides for all 114 PyTorch modules | \n| **[https://app.svetoviz.com](https://app.svetoviz.com)** | Dataset scenes published online, browsable in the browser | \n\nThe written guides published on the website, in the same order as this README:\n\n| Guide | Covers | Link | \n|---|---|---|\n| Overview | What Svetoviz is, the visual-debugger concept, supported data types | [https://www.svetoviz.com/docs](https://www.svetoviz.com/docs) | \n| Installation | Package, dependency list, cache setup, demos | [https://www.svetoviz.com/docs/install](https://www.svetoviz.com/docs/install) | \n| API Reference | Full signatures and parameters for every method, view, layout, remote view and utility | [https://www.svetoviz.com/docs/docs](https://www.svetoviz.com/docs/docs) | \n| Images | `image` /`images` polymorphism, batch inspection, cache configuration | [https://www.svetoviz.com/docs/images](https://www.svetoviz.com/docs/images) | \n| NumPy | Single array inspection, stacking, colormaps, mixed dtypes, axis ordering, large high-dimensional arrays | [https://www.svetoviz.com/docs/numpy](https://www.svetoviz.com/docs/numpy) | \n| Datasets | Building and launching a dataset scene, search database, compression levels | [https://www.svetoviz.com/docs/datasets](https://www.svetoviz.com/docs/datasets) | \n| Views | `View` vs`Layout` , directory views, layout nesting, offline scene building | [https://www.svetoviz.com/docs/views](https://www.svetoviz.com/docs/views) | \n| torch.Tensor | Single tensor inspection, mixed dtypes, stacking, ordering, large tensors | [https://www.svetoviz.com/docs/tensor](https://www.svetoviz.com/docs/tensor) | \n| Models | `model()` vs`pipeline()` , terminal callbacks, non-blocking mode, diffusion pipelines | [https://www.svetoviz.com/docs/models](https://www.svetoviz.com/docs/models) | \n| PyTorch | Wrapping `nn.Module` , the interaction terminal, layer relations and provenance mapping | [https://www.svetoviz.com/docs/pytorch](https://www.svetoviz.com/docs/pytorch) | \n| PyTorch Modules | The illustrated module catalog (114 modules) | [https://pytorch.svetoviz.com](https://pytorch.svetoviz.com) | \n| Activation functions | All 28 supported activation modules | [https://www.svetoviz.com/docs/activations](https://www.svetoviz.com/docs/activations) | \n| Loss functions | All 13 supported loss modules | [https://www.svetoviz.com/docs/loss](https://www.svetoviz.com/docs/loss) | \n\n| Demo | Link | \n|---|---|\n| NumPy array inspection | [https://www.youtube.com/watch?v=fWhK4oPcSf0](https://www.youtube.com/watch?v=fWhK4oPcSf0) | \n| `torch.Tensor` inspection | [https://www.youtube.com/watch?v=IijSmLB1FgY](https://www.youtube.com/watch?v=IijSmLB1FgY) | \n| PyTorch Debugger | [https://www.youtube.com/watch?v=JGBud9nniOM](https://www.youtube.com/watch?v=JGBud9nniOM) | \n| Model analysis (DETR) | [https://www.youtube.com/watch?v=SPCUtlT1298](https://www.youtube.com/watch?v=SPCUtlT1298) | \n| Model debugger (GPT-2) | [https://www.youtube.com/watch?v=LJa9MFEWcWE](https://www.youtube.com/watch?v=LJa9MFEWcWE) | \n| Dataset explorer | [https://www.youtube.com/watch?v=DEuSVW1oJG4](https://www.youtube.com/watch?v=DEuSVW1oJG4) | \n| Image browser | [https://www.youtube.com/watch?v=xHb_U8BAsEs](https://www.youtube.com/watch?v=xHb_U8BAsEs) | \n\n- **Website / public directory:**[https://www.svetoviz.com](https://www.svetoviz.com)\n- **Documentation:**[https://www.svetoviz.com/docs](https://www.svetoviz.com/docs)\n- **PyTorch module guides:**[https://pytorch.svetoviz.com](https://pytorch.svetoviz.com)\n- **Online datasets:**[https://app.svetoviz.com](https://app.svetoviz.com)\n- **Python package wheel index:**[https://svetoviz.com/webgpu/simple/](https://svetoviz.com/webgpu/simple/)\n- **Author - LinkedIn:**[https://www.linkedin.com/in/piotr-gryko-946756101/](https://www.linkedin.com/in/piotr-gryko-946756101/)\n- **Author - GitHub:**[https://github.com/PiotrGryko](https://github.com/PiotrGryko)\n\n**Svetoviz Research** - advancing high-dimensional data visualization and machine learning interpretability.\n\n```\nPiotr Gryko\nul. Prezydenta Ryszarda Kaczorowskiego 14 / 271\n15-375 Bialystok, Poland\n\nNIP:   9662022689\nREGON: 368029613\n```\n\nRegistered in Bialystok, Poland.\n\n**[www.svetoviz.com](https://www.svetoviz.com)** | **[Documentation](https://www.svetoviz.com/docs)** | [PyTorch Debugger](https://pytorch.svetoviz.com)\n\nBuilt for the Global AI Research Community.\n\n**Start visualizing - [open the live Svetoviz viewer](https://www.svetoviz.com)**\n\n**[https://www.svetoviz.com](https://www.svetoviz.com)** - documentation, install commands, pricing and the public model / dataset browser.", "url": "https://wpnews.pro/news/show-hn-svetoviz-visual-debugger-for-large-language-models", "canonical_source": "https://github.com/PiotrGryko/svetoviz", "published_at": "2026-11-19 14:00:16+00:00", "updated_at": "2026-11-19 14:16:16.160565+00:00", "lang": "en", "topics": ["developer-tools", "machine-learning", "ai-tools", "large-language-models"], "entities": ["Svetoviz", "NumPy", "PyTorch", "Hugging Face", "WebGPU", "svetoviz"], "also_reported_by": [], "takeaway": "Svetoviz's `sv.pytorch` debugger traces the input-to-weights-to-output relation of every basic `torch.nn` module and renders it in a local WebGPU browser scene, installable with `pip install svetoviz` on Python 3.9-3.14.", "recommendation": null, "alternates": {"html": "https://wpnews.pro/news/show-hn-svetoviz-visual-debugger-for-large-language-models", "markdown": "https://wpnews.pro/news/show-hn-svetoviz-visual-debugger-for-large-language-models.md", "text": "https://wpnews.pro/news/show-hn-svetoviz-visual-debugger-for-large-language-models.txt", "jsonld": "https://wpnews.pro/news/show-hn-svetoviz-visual-debugger-for-large-language-models.jsonld"}}